### Istio Installation

Source: https://github.com/seldonio/seldon-core/blob/v2/docs-gb/examples/notebooks/istio.ipynb

This command installs Istio using the demo profile. It is a prerequisite for the notebook examples.

```bash
istioctl install --set profile=demo -y
```

--------------------------------

### Install Tritonclient

Source: https://github.com/seldonio/seldon-core/blob/v2/docs-gb/examples/tritonclient-examples.md

Installs the Tritonclient library with all optional dependencies using pip.

```bash
pip install tritonclient[all]
```

--------------------------------

### Install Seldon Core v2 Example Servers

Source: https://github.com/seldonio/seldon-core/blob/v2/docs-gb/installation/production-environment/README.md

Installs example Seldon Core v2 servers, such as mlserver-0 and triton-0. These serve as placeholders for deploying actual models and can be loaded with models after installation.

```bash
helm upgrade seldon-core-v2-servers seldon-charts/seldon-core-v2-servers \
--namespace seldon-mesh \
--install
```

--------------------------------

### Install Example Servers using Helm

Source: https://github.com/seldonio/seldon-core/blob/v2/docs/source/contents/getting-started/kubernetes-installation/helm.md

Installs example MLServer and Triton server custom resources using the `seldon-core-v2-servers` Helm chart. This is useful for initial testing and demonstrates how to deploy models. It installs one MLServer and one Triton server by default.

```bash
helm install seldon-v2-servers seldon-charts/seldon-core-v2-servers --namespace seldon-mesh
```

--------------------------------

### Start Experiment using Seldon CLI

Source: https://github.com/seldonio/seldon-core/blob/v2/docs-gb/examples/local-experiments.md

Starts the 'addmul10' experiment using the `seldon experiment start` command with its YAML configuration file. This command initiates the experiment based on the defined candidate pipelines and weights.

```bash
seldon experiment start -f ./experiments/addmul10.yaml

```

--------------------------------

### Start Seldon Experiment

Source: https://github.com/seldonio/seldon-core/blob/v2/samples/local-experiments.md

Initiates a Seldon experiment using the defined experiment configuration file. This command starts the traffic routing according to the experiment's specifications.

```bash
seldon experiment start -f ./experiments/ab-default-model.yaml

```

--------------------------------

### Install Seldon Core 2 via Helm

Source: https://github.com/seldonio/seldon-core/blob/v2/docs-gb/installation/learning-environment/README.md

This snippet demonstrates the installation of Seldon Core 2 using Helm. It includes commands for creating a namespace, adding and updating Helm repositories, installing CRDs, the operator, runtimes, and example servers. The final command checks the status of the installed pods.

```bash
kubectl create ns seldon-mesh || echo "Namespace seldon-mesh already exists"
helm repo add seldon-charts https://seldonio.github.io/helm-charts/
helm repo update seldon-charts
helm upgrade seldon-core-v2-crds seldon-charts/seldon-core-v2-crds \
--namespace default \
--install 
helm upgrade seldon-core-v2-setup seldon-charts/seldon-core-v2-setup \
--namespace seldon-mesh --set controller.clusterwide=true \
--install
helm upgrade seldon-core-v2-runtime seldon-charts/seldon-core-v2-runtime \
--namespace seldon-mesh \
--install
helm upgrade seldon-core-v2-servers seldon-charts/seldon-core-v2-servers \
--namespace seldon-mesh \
--install
kubectl get pods -n seldon-mesh
```

--------------------------------

### Start Seldon Experiment using CLI (Bash)

Source: https://github.com/seldonio/seldon-core/blob/v2/docs-gb/examples/local-experiments.md

This command starts the 'addmul10-mirror' experiment defined in the specified YAML file. This initiates the traffic routing and mirroring as configured.

```bash
seldon experiment start -f ./experiments/addmul10-mirror.yaml

```

--------------------------------

### Start and Monitor SKlearn Mirror Experiment

Source: https://github.com/seldonio/seldon-core/blob/v2/samples/local-experiments.md

Commands to start the configured SKlearn mirror experiment and then monitor its status until it is active and ready. It uses `jq` to pretty-print the JSON output.

```bash
seldon experiment start -f ./experiments/sklearn-mirror.yaml
seldon experiment status sklearn-mirror -w | jq -M .

```

--------------------------------

### Start and Manage Seldon Experiment using CLI

Source: https://github.com/seldonio/seldon-core/blob/v2/docs-gb/examples/local-experiments.md

Starts, monitors, and stops a Seldon experiment using the Seldon CLI. It includes commands to initiate the experiment, check its status, and terminate it.

```bash
seldon experiment start -f ./experiments/ab-default-model.yaml

```

```bash
seldon experiment status experiment-sample -w | jq -M .

```

```bash
seldon experiment stop experiment-sample

```

--------------------------------

### Install Go License Tools

Source: https://github.com/seldonio/seldon-core/blob/v2/docs-gb/development/licenses.md

Installs the Go license generation tools using the provided setup script. This command assumes Python is installed and accessible in the environment.

```shell
python setup.py install
```

--------------------------------

### Experiment Management (Bash and JSON)

Source: https://github.com/seldonio/seldon-core/blob/v2/samples/local-experiments.md

Commands to start and monitor a Seldon Core experiment. `seldon experiment start` initiates the experiment based on the defined configuration, and `seldon experiment status` provides details about the experiment's current state, including candidate readiness.

```bash
seldon experiment start -f ./experiments/addmul10.yaml

```

```bash
seldon experiment status addmul10 -w | jq -M .

```

--------------------------------

### Start and Monitor Seldon Experiment (Bash)

Source: https://github.com/seldonio/seldon-core/blob/v2/samples/local-examples.md

Starts the 'experiment-sample' A/B test in Seldon Core and then monitors its status until all candidates are ready. The `-w` flag waits for the experiment to become active and stable.

```bash
seldon experiment start -f ./experiments/ab-default-model.yaml
seldon experiment status experiment-sample -w | jq -M .

```

--------------------------------

### Start a Seldon Experiment

Source: https://github.com/seldonio/seldon-core/blob/v2/docs-gb/examples/local-experiments.md

Initiates a Seldon experiment defined in a YAML file. This command sets up A/B testing or canary deployments by configuring candidate models and their weights. It's essential for controlled rollouts and performance comparisons.

```bash
seldon experiment start -f ./experiments/add1020.yaml
```

--------------------------------

### Install MLServer CLI

Source: https://github.com/seldonio/seldon-core/blob/v2/docs/source/contents/examples/batch-examples-local.md

Installs the MLServer CLI using pip. This command is a prerequisite for running batch inference jobs with MLServer.

```bash
pip install mlserver
```

--------------------------------

### Istio Version Check

Source: https://github.com/seldonio/seldon-core/blob/v2/docs-gb/examples/notebooks/istio.ipynb

This command checks the installed version of Istio. It is a prerequisite for the notebook examples to ensure compatibility.

```bash
istioctl version
```

--------------------------------

### Start and Monitor Experiment (Bash)

Source: https://github.com/seldonio/seldon-core/blob/v2/docs-gb/examples/local-examples.md

Commands to start the defined A/B experiment and monitor its status. The `seldon experiment status` command with the `-w` flag waits for the experiment to become ready.

```bash
seldon experiment start -f ./experiments/ab-default-model.yaml

```

```bash
seldon experiment status experiment-sample -w | jq -M .

```

--------------------------------

### List Model Artifacts in Google Cloud Storage

Source: https://github.com/seldonio/seldon-core/blob/v2/docs-gb/getting-started/quickstart/quickstart.ipynb

Lists the contents of a specified Google Cloud Storage bucket folder, which contains the model artifact and its configuration. This command is useful for verifying the presence of necessary files before deployment. It requires the `gcloud` CLI to be installed and configured.

```bash
!gcloud storage ls --recursive gs://seldon-models/scv2/samples/mlserver_1.4.0/income-sklearn/classifier
```

--------------------------------

### Start Experiment with different models using grpcurl

Source: https://github.com/seldonio/seldon-core/blob/v2/scheduler/notebooks/experiments.ipynb

Starts a new experiment, similar to the previous example, but with a different default model and candidate configurations. This highlights the flexibility in defining experiment parameters. Requires scheduler API proto definitions.

```bash
!grpcurl -d '{"experiment":{"name":"exp1", \n               "defaultModel":"iris2", \n                "candidates":[\n                    {"modelName":"iris2","weight":50},\n                    {"modelName":"iris3","weight":50}\n                    ]}}' \         -plaintext \         -import-path ../../apis \         -proto ../../apis/mlops/scheduler/scheduler.proto  0.0.0.0:9004 seldon.mlops.scheduler.Scheduler/StartExperiment
```

```python
!grpcurl -d '{"experiment":{"name":"exp1", \n               "defaultModel":"iris2", \n                "candidates":[\n                    {"modelName":"iris2","weight":50},\n                    {"modelName":"iris3","weight":50}\n                    ]}}' \         -plaintext \         -import-path ../../apis \         -proto ../../apis/mlops/scheduler/scheduler.proto  0.0.0.0:9004 seldon.mlops.scheduler.Scheduler/StartExperiment
```

--------------------------------

### Kubernetes Image Installation (Make)

Source: https://github.com/seldonio/seldon-core/blob/v2/scheduler/README.md

Installs all necessary Seldon Core images into a local Kubernetes cluster (kind) using the 'make kind-image-install-all' command. This prepares the environment for Kubernetes-based testing.

```makefile
make kind-image-install-all
```

--------------------------------

### View Model Configuration from Google Cloud Storage

Source: https://github.com/seldonio/seldon-core/blob/v2/docs-gb/getting-started/quickstart/quickstart.ipynb

Retrieves and displays the content of the `model-settings.json` file from a Google Cloud Storage bucket. This file contains crucial information for loading the model, such as its name, implementation class, and artifact URI. It uses the `gsutil` command-line tool.

```bash
!gsutil cat gs://seldon-models/scv2/samples/mlserver_1.4.0/income-sklearn/classifier/model-settings.json
```

--------------------------------

### Deploy Anchor Tabular Explainer using kubectl

Source: https://github.com/seldonio/seldon-core/blob/v2/docs-gb/examples/explainer-examples.md

Commands to apply the explainer configuration and wait for it to become ready using kubectl. This follows the same pattern as deploying the main model.

```bash
kubectl apply -f ./models/income-explainer.yaml -n ${NAMESPACE}
kubectl wait --for condition=ready --timeout=300s model income-explainer -n ${NAMESPACE}

```

--------------------------------

### Configure Seldon V2 Setup with Kafka Prefixes using Helm

Source: https://github.com/seldonio/seldon-core/blob/v2/docs-gb/examples/notebooks/k8s-clusterwide.ipynb

Installs and configures the Seldon V2 core setup using Helm. This command enables cluster-wide controller mode and sets Kafka topic and consumer group prefixes for isolation when sharing a Kafka cluster. It targets the 'seldon-mesh' namespace.

```shell
!helm upgrade --install seldon-v2 ../k8s/helm-charts/seldon-core-v2-setup/ -n seldon-mesh \
    --set controller.clusterwide=true \
    --set kafka.topicPrefix=myorg \
    --set kafka.consumerGroupIdPrefix=myorg
```

--------------------------------

### Helm Install Command for Seldon Core with Strimzi

Source: https://github.com/seldonio/seldon-core/blob/v2/docs/source/contents/getting-started/kubernetes-installation/security/strimzi-sasl.md

This Helm command installs Seldon Core version 2 with specific configurations for connecting to a Strimzi Kafka cluster using SASL_SSL. It utilizes a custom values file (`values-strimzi-kafka-sasl-scram.yaml`) to override default settings and ensures proper integration with the Kafka setup.

```shell
helm install seldon-v2 k8s/helm-charts/seldon-core-v2-setup/ -n seldon-mesh -f k8s/samples/values-strimzi-kafka-sasl-scram.yaml
```

--------------------------------

### Setup Ecosystem Dependencies in Custom Namespace with Ansible

Source: https://github.com/seldonio/seldon-core/blob/v2/ansible/README.md

Shows how to run the ecosystem setup playbook while specifying a different namespace for the installation, deviating from the default 'seldon-mesh' namespace.

```bash
ansible-playbook playbooks/setup-ecosystem.yaml -e seldon_mesh_namespace=<mynamespace>
```

--------------------------------

### Setup Kafka and Proxy Scheduler - Bash

Source: https://github.com/seldonio/seldon-core/blob/v2/scheduler/notebooks/data-flows-kafka.ipynb

These bash commands initiate Kafka and a local proxy scheduler, which are prerequisites for the Kotlin engine to start correctly. Ensure you are in the correct project directory before execution.

```bash
# .../scheduler
make start-kafka-host
make start-proxy-local
```

--------------------------------

### Deploy Income Model using kubectl

Source: https://github.com/seldonio/seldon-core/blob/v2/docs-gb/examples/explainer-examples.md

Commands to apply the income model configuration and wait for it to become ready using kubectl. This is a standard Kubernetes deployment procedure.

```bash
kubectl apply -f ./models/income.yaml -n ${NAMESPACE}
kubectl wait --for condition=ready --timeout=300s model income -n ${NAMESPACE}

```

--------------------------------

### Get Ambassador Ingress IP

Source: https://github.com/seldonio/seldon-core/blob/v2/docs-gb/examples/notebooks/ambassador.ipynb

This Python snippet retrieves the external IP address of the Ambassador ingress service in the Kubernetes cluster. It assumes Ambassador is installed and accessible. The retrieved IP is stored in an environment variable for subsequent use.

```python
INGRESS_IP=!kubectl get svc emissary-ingress -n emissary -o jsonpath='{.status.loadBalancer.ingress[0].ip}'
INGRESS_IP=INGRESS_IP[0]
import os
os.environ['INGRESS_IP'] = INGRESS_IP
INGRESS_IP
```

--------------------------------

### Setup Seldon Ecosystem with Ansible

Source: https://github.com/seldonio/seldon-core/blob/v2/docs-gb/examples/notebooks/k8s-clusterwide-ssl-demo.ipynb

This command uses Ansible to set up the Seldon ecosystem on the Kubernetes cluster. It navigates to the Ansible directory and executes the 'setup-ecosystem.yaml' playbook. This playbook likely installs necessary components and configurations for Seldon.

```bash
!cd ../ansible && ansible-playbook playbooks/setup-ecosystem.yaml
```

--------------------------------

### Get Seldon Core Servers with kubectl

Source: https://github.com/seldonio/seldon-core/blob/v2/docs-gb/getting-started/quickstart/quickstart.ipynb

This command retrieves a list of Seldon Core servers currently deployed in the 'seldon-mesh' namespace. It helps in verifying the status and configuration of deployed server instances like MLServer and Triton.

```shell
kubectl get servers -n seldon-mesh
```

--------------------------------

### Install Seldon Core with Ecosystem using Ansible (One-liner)

Source: https://github.com/seldonio/seldon-core/blob/v2/ansible/README.md

A single command to install Seldon Core and its ecosystem dependencies (kafka, prometheus, opentelemetry, jager) into a local Kind Kubernetes cluster. It uses a top-level playbook that internally calls other playbooks for cluster creation, ecosystem setup, and Seldon setup.

```bash
ansible-playbook playbooks/seldon-all.yaml
```

--------------------------------

### Display Preprocessor Model Configuration

Source: https://github.com/seldonio/seldon-core/blob/v2/docs-gb/getting-started/quickstart/quickstart.ipynb

This command-line snippet uses `cat` to display the contents of the `preprocessor.yaml` file. This YAML file defines the Seldon Core Model resource, specifying the `storageUri` for model artifacts and any `requirements` needed for deployment.

```bash
!cat ../../../samples/quickstart/models/preprocessor/preprocessor.yaml
```

--------------------------------

### Install Seldon Core v2 Setup with Helm

Source: https://github.com/seldonio/seldon-core/blob/v2/docs-gb/kubernetes/confluent/schema-registry.md

Upgrades or installs the 'seldon-core-v2-setup' Helm chart in the 'seldon-mesh' namespace. It configures the setup to use Schema Registry by specifying the configuration path for security settings.

```bash
helm upgrade seldon-core-v2-setup seldon-charts/seldon-core-v2-setup \
  --namespace seldon-mesh \
  --set security.schemaRegistry.configPath=/mnt/schema-registry \
  --install
```

--------------------------------

### Customize Seldon Core Ansible Installation

Source: https://github.com/seldonio/seldon-core/blob/v2/ansible/README.md

Demonstrates how to pass custom variables to the `seldon-all` Ansible playbook for a more tailored installation. This example shows setting a custom namespace, disabling Prometheus installation, and including custom image configurations.

```bash
ansible-playbook playbooks/seldon-all.yaml -e seldon_mesh_namespace=my-seldon-mesh -e install_prometheus=no -e @playbooks/vars/set-custom-images.yaml
```

--------------------------------

### Build Seldon CLI from Source on Linux

Source: https://github.com/seldonio/seldon-core/blob/v2/docs/source/contents/getting-started/cli.md

This snippet outlines the steps to build the Seldon CLI from source on a Linux system. It requires Go to be installed. The build process clones the repository, navigates to the operator directory, and uses 'make' to build the binary. The output binary will be in `<project-root>/operator/bin`.

```bash
git clone https://github.com/SeldonIO/seldon-core --branch=v2
cd seldon-core/operator
make build-seldon
```

--------------------------------

### Load Seldon Models using CLI

Source: https://github.com/seldonio/seldon-core/blob/v2/docs-gb/examples/local-experiments.md

Loads Seldon models defined in YAML configuration files using the Seldon CLI. This is a prerequisite before performing inference or starting experiments.

```bash
seldon model load -f ./models/sklearn1.yaml
seldon model load -f ./models/sklearn2.yaml

```

--------------------------------

### Install Seldon Core Ecosystem with Ansible

Source: https://github.com/seldonio/seldon-core/blob/v2/ansible/README.md

This snippet shows how to execute the Seldon Core ecosystem setup playbook using Ansible. It demonstrates passing extra variables to customize the installation, such as enabling Kafka installation while disabling a full installation. This allows for granular control over which components are deployed.

```bash
ansible-playbook playbooks/setup-ecosystem.yaml -e full_install=no -e install_kafka=yes
```

--------------------------------

### Install Seldon Core 2 Components using Helm

Source: https://github.com/seldonio/seldon-core/blob/v2/docs-gb/getting-started/kubernetes-installation/helm.md

Installs the main Seldon Core 2 setup, including the operator, into a specified namespace. This enables the management of Seldon Runtimes and Servers. The installation can be configured for namespaced or cluster-wide operation.

```bash
kubectl create namespace seldon-mesh
helm install seldon-core-v2  seldon-charts/seldon-core-v2-setup --namespace seldon-mesh
```

```bash
helm install seldon-core-v2  seldon-charts/seldon-core-v2-setup --namespace seldon-mesh --set controller.clusterwide=true
```

--------------------------------

### Manage Experiment Lifecycle with Seldon CLI (Bash)

Source: https://github.com/seldonio/seldon-core/blob/v2/docs-gb/examples/local-experiments.md

Commands to start, monitor, and stop a Seldon experiment. It includes checking the experiment status using `jq` for JSON parsing.

```bash
seldon experiment start -f ./experiments/sklearn-mirror.yaml

```

```bash
seldon experiment status sklearn-mirror -w | jq -M .

```

```bash
seldon experiment stop sklearn-mirror

```

--------------------------------

### Install Seldon Core v2 Setup with Kafka mTLS

Source: https://github.com/seldonio/seldon-core/blob/v2/docs-gb/examples/notebooks/k8s-clusterwide-kafka-mtls-demo.ipynb

This Helm command installs the Seldon Core v2 setup, enabling cluster-wide functionality and applying the Kafka mTLS configuration. It deploys the core components into the 'seldon-mesh' namespace.

```shell
!helm install seldon-v2 ../k8s/helm-charts/seldon-core-v2-setup/ -n seldon-mesh --set controller.clusterwide=true --values ../k8s/samples/values-strimzi-kafka-mtls.yaml
```

--------------------------------

### Helm Install for Seldon Core v2 Setup with Kafka mTLS

Source: https://github.com/seldonio/seldon-core/blob/v2/samples/k8s-clusterwide-kafka-mtls-demo.md

Installs Seldon Core v2 setup using Helm, enabling cluster-wide mode and applying the Strimzi Kafka mTLS configuration. This deploys Seldon Core components into the 'seldon-mesh' namespace.

```bash
helm install seldon-v2 ../k8s/helm-charts/seldon-core-v2-setup/ -n seldon-mesh --set controller.clusterwide=true --values ../k8s/samples/values-strimzi-kafka-mtls.yaml
```

--------------------------------

### Install Seldon Core 2 in Custom Namespace with Ansible

Source: https://github.com/seldonio/seldon-core/blob/v2/ansible/README.md

Installs Seldon Core 2 using Ansible, specifying a custom namespace. This is necessary if a namespace other than the default 'seldon-mesh' was used during the ecosystem setup.

```bash
ansible-playbook playbooks/setup-seldon.yaml -e seldon_mesh_namespace=<mynamespace>
```

--------------------------------

### Example Seldon CLI Configuration (TLS)

Source: https://github.com/seldonio/seldon-core/blob/v2/docs/source/contents/cli/index.md

An example JSON configuration file for the Seldon CLI, demonstrating how to connect to the Seldon scheduler using TLS and client certificates.

```json
{
    "controlplane":{
	"schedulerHost": "seldon-scheduler.svc:9044",
	"tls": true,
	"keyPath": "/home/certs/seldon-scheduler-client/tls.key",
	"crtPath": "/home/certs/seldon-scheduler-client/tls.crt",
	"caPath": "/home/certs/seldon-scheduler-client/ca.crt"
    }
}
```

--------------------------------

### Loading Seldon Core Models

Source: https://github.com/seldonio/seldon-core/blob/v2/docs-gb/examples/pipeline-examples.md

Demonstrates the command-line usage for loading Seldon Core models into the system. This process makes the defined models available for pipeline creation and inference.

```bash
seldon model load -f ./models/conditional.yaml
seldon model load -f ./models/add10.yaml
seldon model load -f ./models/mul10.yaml
```

--------------------------------

### Setup Ecosystem Dependencies using Ansible

Source: https://github.com/seldonio/seldon-core/blob/v2/ansible/README.md

Installs necessary ecosystem components such as Jaeger and OpenTelemetry collector into a specified namespace. It defaults to the 'seldon-mesh' namespace but can be customized.

```bash
ansible-playbook playbooks/setup-ecosystem.yaml
```

--------------------------------

### Send Inference Request and Receive Response

Source: https://github.com/seldonio/seldon-core/blob/v2/docs-gb/getting-started/quickstart/quickstart.ipynb

Sends an HTTP POST request to the model's inference endpoint with the prepared payload and headers. It then parses and returns the JSON response from the model. This step demonstrates how to interact with the deployed model to get predictions.

```python
import requests
response = requests.post(endpoint, headers=headers, json=inference_request)
response.json()
```

--------------------------------

### Test Deployed Preprocessor Endpoint

Source: https://github.com/seldonio/seldon-core/blob/v2/docs-gb/getting-started/quickstart/quickstart.md

This Python code demonstrates how to send a request to the deployed preprocessing model's inference endpoint. It constructs the endpoint URL, sets necessary headers, defines the inference request payload with the input text, and then uses the `requests` library to make a POST request. The response, containing the processed numerical data, is then printed.

```python
endpoint_pp = f"http://{MESH_IP}/v2/models/preprocessor/infer"
headers_pp = {
    "Seldon-Model": "preprocessor",
    }

input_text = '''
"Age": "47",
"Workclass": "4",
"Education": "1",
"Marital Status": "1",
"Occupation": "1",
"Relationship": "0",
"Race": "4",
"Sex": "1",
"Capital Gain": "0",
"Capital Loss": "0",
"Hours per week": "68",
"Country": "9",
"Name": "John Doe"
'''

text_inference_request = {
    "inputs": [
        {
            "name": "text_input", 
            "shape": [1],
            "datatype": "BYTES", 
            "data": [input_text]
        }
    ]
}

import requests
response = requests.post(endpoint_pp, headers=headers_pp, json=text_inference_request)
response.json()
```

--------------------------------

### Configure Seldon Core v2 Setup with Kafka Prefixes

Source: https://github.com/seldonio/seldon-core/blob/v2/docs-gb/examples/k8s-clusterwide.md

Installs the Seldon Core v2 setup with cluster-wide controller enabled and Kafka topic/consumer group prefixes set to 'myorg'. This is useful for isolating Kafka resources when the cluster is shared.

```bash
helm upgrade --install seldon-v2 ../k8s/helm-charts/seldon-core-v2-setup/ -n seldon-mesh \
    --set controller.clusterwide=true \
    --set kafka.topicPrefix=myorg \
    --set kafka.consumerGroupIdPrefix=myorg
```

--------------------------------

### Deploy Preprocessor Model

Source: https://github.com/seldonio/seldon-core/blob/v2/docs-gb/getting-started/quickstart/quickstart.md

This section shows the commands and configuration for deploying a Python preprocessing script as a Seldon Core Model. It includes listing the model artifacts in Google Cloud Storage, displaying the `preprocessor.yaml` configuration file, and applying the deployment to Kubernetes using `kubectl apply`. The `preprocessor.yaml` specifies the storage URI and any necessary requirements.

```bash
!gcloud storage ls --recursive gs://seldon-models/scv2/samples/preprocessor
```

```yaml
apiVersion: mlops.seldon.io/v1alpha1
kind: Model
metadata:
    name: preprocessor
spec:
    storageUri: "gs://seldon-models/scv2/samples/preprocessor"
    requirements:
    - income-classifier-deps
```

```bash
!kubectl apply -f ../../../samples/quickstart/models/preprocessor/preprocessor.yaml -n seldon-mesh
```

--------------------------------

### Install Seldon V2 Runtime in Namespace ns1

Source: https://github.com/seldonio/seldon-core/blob/v2/docs-gb/examples/notebooks/k8s-clusterwide.ipynb

Deploys the Seldon V2 runtime component into the 'ns1' Kubernetes namespace using Helm. The '--wait' flag ensures the command waits until the deployment is ready.

```shell
!helm install seldon-v2-runtime ../k8s/helm-charts/seldon-core-v2-runtime  -n ns1 --wait
```

--------------------------------

### Create Custom MLServer

Source: https://github.com/seldonio/seldon-core/blob/v2/docs-gb/getting-started/quickstart/quickstart.md

Applies a Kubernetes Server manifest to deploy a custom MLServer instance. This server is configured with specific capabilities ('income-classifier-deps') and uses the 'seldonio/mlserver:1.6.0' image, intended for running models with defined dependencies.

```yaml
apiVersion: mlops.seldon.io/v1alpha1
kind: Server
metadata:
  name: mlserver-custom
spec:
  serverConfig: mlserver
  capabilities:
  - income-classifier-deps
  podSpec:
    containers:
    - image: seldonio/mlserver:1.6.0
      name: mlserver
```

--------------------------------

### Install Seldon Core Operator with Helm

Source: https://github.com/seldonio/seldon-core/blob/v2/docs-gb/installation/production-environment/kafka/managed-kafka.md

This command installs or upgrades the Seldon Core 2 operator using Helm. It specifies the chart version, uses a custom `components-values.yaml` file for configuration, and installs into the `seldon-system` namespace.

```bash
helm upgrade seldon-core-v2-components seldon-charts/seldon-core-v2-setup \
 --version 2.8.0 \
 -f components-values.yaml \
 --namespace seldon-system \
 --install
```

--------------------------------

### Install Prometheus with kube-prometheus

Source: https://github.com/seldonio/seldon-core/blob/v2/prometheus/README.md

Applies necessary Kubernetes manifests for Prometheus setup, including a wait loop for ServiceMonitors to ensure readiness before proceeding. This is the primary installation command.

```bash
kubectl apply --server-side -f manifests/setup
until kubectl get servicemonitors --all-namespaces ; do date; sleep 1; echo ""; done
kubectl apply -f manifests/
```

--------------------------------

### Display Seldon Model Manifest

Source: https://github.com/seldonio/seldon-core/blob/v2/docs-gb/getting-started/quickstart/quickstart.ipynb

Prints the content of a Kubernetes manifest file for a Seldon Core Model. This YAML file defines the model's deployment specifications, including its storage location (`storageUri`), dependencies (`requirements`), and resource allocation (memory). It uses the `cat` command to display the file content.

```bash
!cat ../../../samples/quickstart/models/sklearn-income-classifier.yaml
```

--------------------------------

### Install Seldon V2 Runtime and Servers

Source: https://github.com/seldonio/seldon-core/blob/v2/docs-gb/examples/notebooks/k8s-clusterwide-ssl-demo.ipynb

These commands install the Seldon V2 runtime and server components into namespaces 'ns1' and 'ns2' using Helm. They utilize the respective Helm charts ('seldon-core-v2-runtime' and 'seldon-core-v2-servers'). Ensure these charts are available in the specified paths.

```bash
!helm install seldon-v2-runtime ../k8s/helm-charts/seldon-core-v2-runtime  -n ns1
!helm install seldon-v2-servers ../k8s/helm-charts/seldon-core-v2-servers  -n ns1
!helm install seldon-v2-runtime ../k8s/helm-charts/seldon-core-v2-runtime  -n ns2
!helm install seldon-v2-servers ../k8s/helm-charts/seldon-core-v2-servers  -n ns2
```

--------------------------------

### Check Seldon Binary Installation

Source: https://github.com/seldonio/seldon-core/blob/v2/scheduler/notebooks/pipeline-batch-data-flow-example.ipynb

Verifies if the 'seldon' binary is installed and accessible in the system's PATH. This is a prerequisite for executing subsequent Seldon CLI commands.

```shell
!which seldon
```

--------------------------------

### Protobuf Compiler Version Check (Shell)

Source: https://github.com/seldonio/seldon-core/blob/v2/scheduler/README.md

Checks the installed version of the Protocol Buffers compiler (protoc). This is a prerequisite for gRPC development. Displays the libprotoc version if installed.

```shell
protoc --version
```

--------------------------------

### Deploy Pipeline using Kubectl

Source: https://github.com/seldonio/seldon-core/blob/v2/docs-gb/getting-started/quickstart/quickstart.md

This command deploys the defined Seldon Core pipeline to the Kubernetes cluster. It utilizes `kubectl apply` with the specified YAML file and targets the 'seldon-mesh' namespace. Ensure the pipeline YAML file path is correct before execution.

```bash
!kubectl apply -f ../../../samples/quickstart/pipelines/income-classifier-app.yaml -n seldon-mesh
```

--------------------------------

### Deploy Anchor Text Explainer with kubectl

Source: https://github.com/seldonio/seldon-core/blob/v2/docs-gb/examples/explainer-examples.md

Deploys the Anchor Text Explainer for the sentiment model using kubectl and waits for its readiness. Includes an example inference request, although the output is not shown.

```bash
kubectl apply -f ./models/moviesentiment-explainer.yaml -n ${NAMESPACE}

```

```bash
kubectl wait --for condition=ready --timeout=300s model sentiment-explainer -n ${NAMESPACE}

```

```bash
curl --location 'http://${SELDON_INFER_HOST}/v2/models/iris/infer' \
	--header 'Content-Type: application/json'  \
    --data '{"parameters": {"content_type": "str"}, "inputs": [{"name": "foo", "data": ["I am good"], "datatype": "BYTES","shape": [1]}]}'

```

--------------------------------

### Deploy Anchor Text Explainer with seldon-cli

Source: https://github.com/seldonio/seldon-core/blob/v2/docs-gb/examples/explainer-examples.md

Loads and checks the status of the Anchor Text Explainer using seldon-cli. Includes an example of sending an inference request via the CLI.

```bash
seldon model load -f ./models/moviesentiment-explainer.yaml

```

```bash
seldon model status sentiment-explainer -w ModelAvailable

```

```bash
seldon model infer sentiment-explainer \
  '{"parameters": {"content_type": "str"}, "inputs": [{"name": "foo", "data": ["I am good"], "datatype": "BYTES","shape": [1]}]}'

```

--------------------------------

### Clone Repository and Build Seldon CLI

Source: https://github.com/seldonio/seldon-core/blob/v2/docs/source/contents/getting-started/docker-installation/index.md

This snippet shows how to clone the Seldon Core repository to a specific branch and build the Seldon CLI. It requires git and make to be installed.

```bash
git clone https://github.com/SeldonIO/seldon-core --branch=v2
make build-cli
```

--------------------------------

### Local Install: Kafka Topic for Model Inference

Source: https://github.com/seldonio/seldon-core/blob/v2/docs-gb/inference.md

Example of a Kafka topic for sending inference requests to a local Seldon Core installation with a model named 'iris' in the 'default' namespace.

```plaintext
seldon.default.model.iris.inputs
seldon.default.model.iris.outputs
```

--------------------------------

### Create and Deploy Income Pipeline

Source: https://github.com/seldonio/seldon-core/blob/v2/samples/k8s-explainers.md

This section shows the creation of an 'income-prod' pipeline using a YAML file. It defines a simple pipeline with a single step named 'income'. The kubectl create command deploys this pipeline.

```bash
cat ./pipelines/income-v1.yaml
```yaml
apiVersion: mlops.seldon.io/v1alpha1
kind: Pipeline
metadata:
  name: income-prod
spec:
  steps:
    - name: income
  output:
    steps:
    - income

```

kubectl create -f ./pipelines/income-v1.yaml -n ${NAMESPACE}

```

--------------------------------

### Install Seldon Core 2 Runtime using Helm

Source: https://github.com/seldonio/seldon-core/blob/v2/docs/source/contents/getting-started/kubernetes-installation/helm.md

Deploys a SeldonRuntime custom resource, which installs the core components needed to manage resources within a specific namespace. This chart installs the Seldon controller into the specified namespace.

```bash
helm install seldon-v2-runtime seldon-charts/seldon-core-v2-runtime --namespace seldon-mesh
```

--------------------------------

### Start an A/B Experiment using Seldon CLI

Source: https://github.com/seldonio/seldon-core/blob/v2/samples/experiment_versions.md

Starts a defined Seldon Core experiment using the `seldon experiment start` command, applying the A/B testing configuration.

```bash
seldon experiment start -f ./experiments/ab-default-model.yaml
```

--------------------------------

### Deploy MLFlow Wine Model using kubectl

Source: https://github.com/seldonio/seldon-core/blob/v2/docs-gb/examples/model-zoo.md

Commands to deploy the MLFlow Wine Model using kubectl. It includes applying the model configuration and waiting for the model to become ready.

```bash
kubectl apply -f ./models/wine-mlflow.yaml -n ${NAMESPACE}

```

```bash
kubectl wait --for condition=ready --timeout=300s model wine -n ${NAMESPACE}

```

--------------------------------

### Go gRPC Plugin Installation (Shell)

Source: https://github.com/seldonio/seldon-core/blob/v2/scheduler/README.md

Installs the necessary Go plugins for gRPC development, specifically `protoc-gen-go` and `protoc-gen-go-grpc`. These are required for generating Go code from Protocol Buffers definitions.

```shell
go install google.golang.org/protobuf/cmd/protoc-gen-go@v1.26
go install google.golang.org/grpc/cmd/protoc-gen-go-grpc@v1.1
```

--------------------------------

### Create and Wait for Seldon Experiment Readiness

Source: https://github.com/seldonio/seldon-core/blob/v2/samples/k8s-examples.md

Creates the defined Seldon Experiment in Kubernetes and then waits for it to become ready. This indicates the experiment configuration has been successfully applied.

```bash
kubectl create -f ./experiments/ab-default-model.yaml -n ${NAMESPACE}
```

```bash
kubectl wait --for condition=ready --timeout=300s experiment --all -n ${NAMESPACE}
```

--------------------------------

### Install Seldon Core v2 CRDs using Helm

Source: https://github.com/seldonio/seldon-core/blob/v2/docs-gb/examples/k8s-clusterwide.md

Installs the Seldon Core v2 Custom Resource Definitions (CRDs) into the 'seldon-mesh' namespace using Helm. This is a prerequisite for deploying Seldon Core components.

```bash
helm upgrade --install seldon-core-v2-crds  ../k8s/helm-charts/seldon-core-v2-crds -n seldon-mesh
```

--------------------------------

### Deploy Income Model using seldon-cli

Source: https://github.com/seldonio/seldon-core/blob/v2/docs-gb/examples/explainer-examples.md

Commands for managing the income model deployment using the Seldon CLI. This includes unloading previous models, loading the new model, and checking its status.

```bash
seldon model unload mnist-pytorch
seldon model load -f ./models/income.yaml
seldon model status income -w ModelAvailable

```

--------------------------------

### Kubernetes Install (seldon-mesh): Kafka Topic for Model Inference

Source: https://github.com/seldonio/seldon-core/blob/v2/docs-gb/inference.md

Example of a Kafka topic for sending inference requests to a Seldon Core installation within the 'seldon-mesh' Kubernetes namespace with a model named 'iris'.

```plaintext
seldon.seldon-mesh.model.iris.inputs
seldon.seldon-mesh.model.iris.outputs
```

--------------------------------

### Starting a Seldon Experiment

Source: https://github.com/seldonio/seldon-core/blob/v2/docs-gb/examples/notebooks/local-experiments.ipynb

This command starts a Seldon experiment defined by the provided YAML file. It initiates the experiment based on the configuration specified in './experiments/add1020.yaml'.

```shell
!seldon experiment start -f ./experiments/add1020.yaml
```

--------------------------------

### Display Pipeline Configuration

Source: https://github.com/seldonio/seldon-core/blob/v2/docs-gb/examples/notebooks/inference.ipynb

Displays the contents of the pipeline configuration file './pipelines/tfsimple.yaml'. This file defines the steps included in the pipeline.

```bash
!cat ./pipelines/tfsimple.yaml

```

--------------------------------

### Load Identity Output Model (Seldon CLI)

Source: https://github.com/seldonio/seldon-core/blob/v2/docs-gb/examples/pipeline-cyclic.md

Deploys the 'identity-output' model by loading its manifest file. This step ensures the output model is ready for the pipeline.

```bash
seldon model load -f ./models/identity-output.yaml
```

--------------------------------

### Deploy Seldon Core Pipeline using kubectl (Shell)

Source: https://github.com/seldonio/seldon-core/blob/v2/docs-gb/getting-started/quickstart/quickstart.ipynb

This command applies the Seldon Core pipeline configuration defined in the 'income-classifier-app.yaml' file to the 'seldon-mesh' namespace. It ensures that the pipeline is created and ready to be used for inference.

```shell
!kubectl apply -f ../../../samples/quickstart/pipelines/income-classifier-app.yaml -n seldon-mesh

```

--------------------------------

### Install Seldon v2 Runtime and Servers in Namespace ns2

Source: https://github.com/seldonio/seldon-core/blob/v2/docs-gb/examples/k8s-clusterwide.md

Installs the Seldon v2 runtime and Seldon v2 servers into the 'ns2' namespace using Helm. The '--wait' flag ensures the command waits for the resources to be deployed.

```bash
helm install seldon-v2-runtime ../k8s/helm-charts/seldon-core-v2-runtime  -n ns2 --wait
helm install seldon-v2-servers ../k8s/helm-charts/seldon-core-v2-servers  -n ns2 --wait
```

--------------------------------

### Start Seldon Core Experiment

Source: https://github.com/seldonio/seldon-core/blob/v2/samples/local-experiments.ipynb

Initiates a Seldon Core experiment defined in a YAML file. This command loads the experiment configuration and begins the process of evaluating candidate pipelines.

```bash
!seldon experiment start -f ./experiments/addmul10.yaml 
```

--------------------------------

### Install Seldon v2 Runtime and Servers in Namespace ns1

Source: https://github.com/seldonio/seldon-core/blob/v2/docs-gb/examples/k8s-clusterwide.md

Installs the Seldon v2 runtime and Seldon v2 servers into the 'ns1' namespace using Helm. The '--wait' flag ensures the command waits for the resources to be deployed.

```bash
helm install seldon-v2-runtime ../k8s/helm-charts/seldon-core-v2-runtime  -n ns1 --wait
helm install seldon-v2-servers ../k8s/helm-charts/seldon-core-v2-servers  -n ns1 --wait
```

--------------------------------

### Display Seldon CLI Help Information

Source: https://github.com/seldonio/seldon-core/blob/v2/docs-gb/getting-started/cli.md

Displays the help information for the Seldon CLI tool, showing available commands and options. This is a fundamental command for understanding the CLI's capabilities.

```shell
seldon --help
```

--------------------------------

### Helm Install: Enable SSL for Data Plane

Source: https://github.com/seldonio/seldon-core/blob/v2/docs/source/contents/getting-started/kubernetes-installation/security/index.md

This command installs the Seldon Core v2 setup with SSL enabled for the data plane. It configures Envoy's protocol to SSL, ensuring secure communication for data plane operations.

```bash
helm install seldon-v2 k8s/helm-charts/seldon-core-v2-setup/ -n seldon-mesh --set security.envoy.protocol=SSL
```

--------------------------------

### Helm Install: Enable SSL for Control Plane

Source: https://github.com/seldonio/seldon-core/blob/v2/docs/source/contents/getting-started/kubernetes-installation/security/index.md

This command installs the Seldon Core v2 setup with SSL enabled for the control plane. It uses Helm to deploy the specified chart and sets the control plane security protocol to SSL.

```bash
helm install seldon-v2 k8s/helm-charts/seldon-core-v2-setup/ -n seldon-mesh \
      --set security.controlplane.protocol=SSL
```

--------------------------------

### Load LightGBM Model Configuration

Source: https://github.com/seldonio/seldon-core/blob/v2/samples/model-zoo.md

Loads a LightGBM model using its YAML configuration file. This command prepares the model for deployment within the Seldon Core environment. It requires the path to the YAML file as input.

```bash
cat ./models/income-lgb.yaml

```

```yaml
apiVersion: mlops.seldon.io/v1alpha1
kind: Model
metadata:
  name: income-lgb
spec:
  storageUri: "gs://seldon-models/scv2/samples/mlserver_1.3.5/income-lgb"
  requirements:
  - lightgbm

```

```bash
seldon model load -f ./models/income-lgb.yaml

```

--------------------------------

### Seldon Inference with Headers and Sticky Session using CLI

Source: https://github.com/seldonio/seldon-core/blob/v2/docs-gb/examples/local-experiments.md

Demonstrates performing inference requests with options to show headers and enable sticky sessions using the Seldon CLI. Sticky sessions ensure subsequent requests from the same client are routed to the same model instance.

```bash
seldon model infer iris --show-headers \
  '{"inputs": [{"name": "predict", "shape": [1, 4], "datatype": "FP32", "data": [[1, 2, 3, 4]]}]}'

```

```bash
seldon model infer iris -s -i 50 \
  '{"inputs": [{"name": "predict", "shape": [1, 4], "datatype": "FP32", "data": [[1, 2, 3, 4]]}]}'

```

```bash
seldon model infer iris --inference-mode grpc -s -i 50 \
   '{"model_name":"iris","inputs":[{"name":"input","contents":{"fp32_contents":[1,2,3,4]},"datatype":"FP32","shape":[1,4]}]}'

```

--------------------------------

### Get Income Model Status

Source: https://github.com/seldonio/seldon-core/blob/v2/samples/k8s-explainers.md

This command retrieves the status of the 'income' model in JSON format. It uses kubectl to get the model details and jq to format the output, allowing inspection of the model's readiness conditions and replica count.

```bash
kubectl get model income -n ${NAMESPACE} -o jsonpath='{.status}' | jq -M .

```

--------------------------------

### List Cloud Storage Contents for Preprocessor Model

Source: https://github.com/seldonio/seldon-core/blob/v2/docs-gb/getting-started/quickstart/quickstart.ipynb

This command-line snippet uses the `gcloud` utility to list the recursive contents of a specified Google Cloud Storage bucket. This is used to verify that the necessary model artifacts, including `model-settings.json` and `model.py`, are present for deployment.

```bash
!gcloud storage ls --recursive gs://seldon-models/scv2/samples/preprocessor
```

--------------------------------

### Enable GPU Support for Seldon Core Deployment

Source: https://github.com/seldonio/seldon-core/blob/v2/docs-gb/getting-started/docker-installation.md

To enable GPU support for Seldon Core deployment, first ensure that the nvidia-container-runtime is installed on your system. Then, set the GPU_ENABLED environment variable to 1 before running the deployment command.

```sh
export GPU_ENABLED=1
```

--------------------------------

### Create Income Explainer Model Deployment

Source: https://github.com/seldonio/seldon-core/blob/v2/docs-gb/examples/notebooks/k8s-explainers.ipynb

Creates the income explainer model deployment in Kubernetes using its YAML configuration. This command deploys the explainer alongside the primary model.

```shell
!kubectl create -f ./models/income-explainer.yaml -n ${NAMESPACE}
```

--------------------------------

### Install Seldon Core v2 Certificates using Helm

Source: https://github.com/seldonio/seldon-core/blob/v2/samples/k8s-clusterwide-ssl-demo.md

Installs the Seldon Core v2 certificates using Helm in the specified namespaces ('ns1' and 'ns2'). This is crucial for enabling SSL/TLS communication within the Seldon Core setup.

```bash
helm install seldon-v2-certs ../k8s/helm-charts/seldon-core-v2-certs/ -n ns1
```

```bash
helm install seldon-v2-certs ../k8s/helm-charts/seldon-core-v2-certs/ -n ns2
```

--------------------------------

### Kubernetes: Example Pod Status Output

Source: https://github.com/seldonio/seldon-core/blob/v2/docs-gb/installation/learning-environment/self-hosted-kafka.md

An example output showing the status of various pods in the 'seldon-mesh' namespace, including Kafka brokers, Strimzi operator, and other Seldon components.

```bash
NAME                                            READY   STATUS    RESTARTS      AGE
hodometer-5489f768bf-9xnmd                      1/1     Running   0             25m
mlserver-0                                      3/3     Running   0             24m
seldon-dataflow-engine-75f9bf6d8f-2blgt         1/1     Running   5 (23m ago)   25m
seldon-envoy-7c764cc88-xg24l                    1/1     Running   0             25m
seldon-kafka-0                                  1/1     Running   0             21m
seldon-kafka-1                                  1/1     Running   0             21m
seldon-kafka-2                                  1/1     Running   0             21m
seldon-modelgateway-54d457794-x4nzq             1/1     Running   0             25m
seldon-pipelinegateway-6957c5f9dc-6blx6         1/1     Running   0             25m
seldon-scheduler-0                              1/1     Running   0             25m
seldon-v2-controller-manager-7b5df98677-4jbpp   1/1     Running   0             25m
strimzi-cluster-operator-66b5ff8bbb-qnr4l       1/1     Running   0             23m
triton-0                                        3/3     Running   0             24m
```

--------------------------------

### Get Explainer Model Status

Source: https://github.com/seldonio/seldon-core/blob/v2/samples/k8s-examples.md

This command retrieves the status of the deployed 'income-explainer' model. Similar to the income model status retrieval, it uses `kubectl get model` and `jq` to display the model's readiness and conditions in a human-readable JSON format.

```bash
kubectl get model income-explainer -n ${NAMESPACE} -o jsonpath='{.status}' | jq -M .
```

--------------------------------

### Display Model YAML Files

Source: https://github.com/seldonio/seldon-core/blob/v2/docs-gb/examples/notebooks/k8s-examples.ipynb

Displays the content of three Seldon Model YAML configuration files. These files define individual machine learning models, specifying their storage URIs, requirements, and memory allocation.

```bash
!cat ./models/tfsimple1.yaml
!cat ./models/tfsimple2.yaml
!cat ./models/tfsimple3.yaml
```

--------------------------------

### Create Income Explainer Model

Source: https://github.com/seldonio/seldon-core/blob/v2/docs-gb/examples/notebooks/k8s-explainers.ipynb

This command creates the income explainer model resource in the specified Kubernetes namespace using its YAML configuration. The output confirms the successful creation of the model.

```bash
!kubectl create -f ./models/income-explainer-pipeline.yaml -n ${NAMESPACE}
```

--------------------------------

### Seldon Experiment Configuration Example (YAML)

Source: https://github.com/seldonio/seldon-core/blob/v2/docs-gb/examples/local-experiments.md

Defines a Seldon experiment named 'add1020' for A/B testing. It specifies a default model and two candidates, 'add10' and 'add20', each with a 50% weight. This configuration is used by `seldon experiment start`.

```yaml
apiVersion: mlops.seldon.io/v1alpha1
kind: Experiment
metadata:
  name: add1020
spec:
  default: add10
  candidates:
  - name: add10
    weight: 50
  - name: add20
    weight: 50
```

--------------------------------

### Get Model Information with curl

Source: https://github.com/seldonio/seldon-core/blob/v2/scheduler/notebooks/scheduler-local-test.ipynb

Retrieves information about a specific model (iris) using curl. It sends a GET request to the /v2/models/iris endpoint, including the seldon-model header. The response provides details about the model's name, versions, platform, and inputs/outputs.

```shell
!curl -v http://0.0.0.0:9000/v2/models/iris -H "seldon-model: iris"
```

--------------------------------

### Get Model Metadata

Source: https://github.com/seldonio/seldon-core/blob/v2/docs-gb/examples/local-examples.md

Retrieves metadata for the deployed Tensorflow model, including its inputs and outputs.

```APIDOC
## Get Model Metadata

Retrieves metadata for the deployed Tensorflow model, including its inputs and outputs, using `curl` or `seldon-cli`.

### Method
`curl` or `seldon model metadata`

### Endpoint
`/v2/models/{model_name}`

### Parameters

#### Path Parameters
- **model_name** (string) - Required - The name of the model.

### Request Example (curl)
```bash
curl --location 'http://${SELDON_INFER_HOST}/v2/models/tfsimple1'
```

### Request Example (seldon-cli)
```bash
seldon model metadata tfsimple1
```

### Response
#### Success Response (200)
- **name** (string) - The name of the model.
- **versions** (array) - An array of model version strings.
- **platform** (string) - The inference platform (e.g., `tensorflow_graphdef`).
- **inputs** (array) - An array of input tensor specifications.
  - **name** (string) - Input tensor name.
  - **datatype** (string) - Data type of the input tensor.
  - **shape** (array) - Shape of the input tensor.
- **outputs** (array) - An array of output tensor specifications.
  - **name** (string) - Output tensor name.
  - **datatype** (string) - Data type of the output tensor.
  - **shape** (array) - Shape of the output tensor.

#### Response Example
```json
{
	"name": "tfsimple1_1",
	"versions": [
		"1"
	],
	"platform": "tensorflow_graphdef",
	"inputs": [
		{
			"name": "INPUT0",
			"datatype": "INT32",
			"shape": [
				-1,
				16
			]
		},
		{
			"name": "INPUT1",
			"datatype": "INT32",
			"shape": [
				-1,
				16
			]
		}
	],
	"outputs": [
		{
			"name": "OUTPUT0",
			"datatype": "INT32",
			"shape": [
				-1,
				16
			]
		},
		{
			"name": "OUTPUT1",
			"datatype": "INT32",
			"shape": [
				-1,
				16
			]
		}
	]
}
```
```

--------------------------------

### Seldon CLI Config Management Commands

Source: https://github.com/seldonio/seldon-core/blob/v2/docs/source/contents/cli/index.md

Examples of using the `seldon config` command to manage configuration files, including listing, deactivating, adding, and activating configurations.

```bash
$ seldon config list
config		path					active
------		----					------
kind-sasl	/home/work/seldon/cli/config-sasl.json		*

$ seldon config deactivate kind-sasl

$ seldon config list
config		path					active
------		----					------
kind-sasl	/home/work/seldon/cli/config-sasl.json

$ seldon config add gcp-scv2 ~/seldon/cli/gcp.json

$ seldon config list
config		path					active
------		----					------
gcp-scv2	/home/work/seldon/cli/gcp.json
kind-sasl	/home/work/seldon/cli/config-sasl.json

$ seldon config activate gcp-scv2

$ seldon config list
config		path					active
------		----					------
gcp-scv2	/home/work/seldon/cli/gcp.json	    	*
kind-sasl	/home/work/seldon/cli/config-sasl.json
```