diff --git a/doc/source/analytics/cat.png b/doc/source/analytics/cat.png
new file mode 100644
index 0000000000..28109120f4
Binary files /dev/null and b/doc/source/analytics/cat.png differ
diff --git a/doc/source/analytics/cat_explanation.png b/doc/source/analytics/cat_explanation.png
new file mode 100644
index 0000000000..a739edc595
Binary files /dev/null and b/doc/source/analytics/cat_explanation.png differ
diff --git a/doc/source/analytics/explainers.md b/doc/source/analytics/explainers.md
new file mode 100644
index 0000000000..ddcc75150e
--- /dev/null
+++ b/doc/source/analytics/explainers.md
@@ -0,0 +1,10 @@
+# Model Explainers
+
+![cat](cat.png)
+![explanation](cat_explanation.png)
+
+Seldon provides model explanations using its [Alibi](https://github.com/SeldonIO/alibi)  Open Sourve library.
+
+We provide [an example notebook](../examples/explainer_examples.html) showing how to deploy an explainer for Tabular, Text and Image models.
+
+
diff --git a/doc/source/examples/explainer_examples.nblink b/doc/source/examples/explainer_examples.nblink
new file mode 100644
index 0000000000..568d31f48f
--- /dev/null
+++ b/doc/source/examples/explainer_examples.nblink
@@ -0,0 +1,3 @@
+{
+  "path": "../../../notebooks/explainer_examples.ipynb"
+}
diff --git a/doc/source/examples/notebooks.rst b/doc/source/examples/notebooks.rst
index 3ecc6cabfa..6812a1651f 100644
--- a/doc/source/examples/notebooks.rst
+++ b/doc/source/examples/notebooks.rst
@@ -18,6 +18,7 @@ Notebooks
    Custom Endpoints <custom_endpoints>
    Example Helm Deployments <helm_examples>
    Explainer Alibi Anchor Tabular <alibi_anchor_tabular>
+   Tabular, Text and Image Model Explainers <explainer_examples>
    Go Model <go_example>
    GPU Tensorflow Deep MNIST <gpu_tensorflow_deep_mnist>
    H2O Java MoJo <h2o_mojo>
diff --git a/doc/source/index.rst b/doc/source/index.rst
index a0c2d63f53..c27a1f1b2e 100644
--- a/doc/source/index.rst
+++ b/doc/source/index.rst
@@ -88,6 +88,7 @@ Seldon Core is an open source platform for deploying machine learning models on
    :maxdepth: 1
    :caption: ML Compliance and Governance
 
+   Model Explanations <analytics/explainers.md>
    Outlier Detection <analytics/outlier_detection.md>
    Routers (incl. Multi Armed Bandits)  <analytics/routers.md>   
    
diff --git a/doc/source/python/api/seldon_core.proto.rst b/doc/source/python/api/seldon_core.proto.rst
index d753287dea..47fca459d1 100644
--- a/doc/source/python/api/seldon_core.proto.rst
+++ b/doc/source/python/api/seldon_core.proto.rst
@@ -2,9 +2,9 @@ seldon\_core.proto package
 ==========================
 
 .. automodule:: seldon_core.proto
-   :members:
-   :undoc-members:
-   :show-inheritance:
+    :members:
+    :undoc-members:
+    :show-inheritance:
 
 Submodules
 ----------
@@ -13,15 +13,16 @@ seldon\_core.proto.prediction\_pb2 module
 -----------------------------------------
 
 .. automodule:: seldon_core.proto.prediction_pb2
-   :members:
-   :undoc-members:
-   :show-inheritance:
+    :members:
+    :undoc-members:
+    :show-inheritance:
 
 seldon\_core.proto.prediction\_pb2\_grpc module
 -----------------------------------------------
 
 .. automodule:: seldon_core.proto.prediction_pb2_grpc
-   :members:
-   :undoc-members:
-   :show-inheritance:
+    :members:
+    :undoc-members:
+    :show-inheritance:
+
 
diff --git a/doc/source/python/api/seldon_core.rst b/doc/source/python/api/seldon_core.rst
index 7d47b69fd3..20ad6ceccf 100644
--- a/doc/source/python/api/seldon_core.rst
+++ b/doc/source/python/api/seldon_core.rst
@@ -2,16 +2,16 @@ seldon\_core package
 ====================
 
 .. automodule:: seldon_core
-   :members:
-   :undoc-members:
-   :show-inheritance:
+    :members:
+    :undoc-members:
+    :show-inheritance:
 
 Subpackages
 -----------
 
 .. toctree::
 
-   seldon_core.proto
+    seldon_core.proto
 
 Submodules
 ----------
@@ -20,111 +20,112 @@ seldon\_core.api\_tester module
 -------------------------------
 
 .. automodule:: seldon_core.api_tester
-   :members:
-   :undoc-members:
-   :show-inheritance:
+    :members:
+    :undoc-members:
+    :show-inheritance:
 
 seldon\_core.flask\_utils module
 --------------------------------
 
 .. automodule:: seldon_core.flask_utils
-   :members:
-   :undoc-members:
-   :show-inheritance:
+    :members:
+    :undoc-members:
+    :show-inheritance:
 
 seldon\_core.metrics module
 ---------------------------
 
 .. automodule:: seldon_core.metrics
-   :members:
-   :undoc-members:
-   :show-inheritance:
+    :members:
+    :undoc-members:
+    :show-inheritance:
 
 seldon\_core.microservice module
 --------------------------------
 
 .. automodule:: seldon_core.microservice
-   :members:
-   :undoc-members:
-   :show-inheritance:
+    :members:
+    :undoc-members:
+    :show-inheritance:
 
 seldon\_core.microservice\_tester module
 ----------------------------------------
 
 .. automodule:: seldon_core.microservice_tester
-   :members:
-   :undoc-members:
-   :show-inheritance:
+    :members:
+    :undoc-members:
+    :show-inheritance:
 
 seldon\_core.persistence module
 -------------------------------
 
 .. automodule:: seldon_core.persistence
-   :members:
-   :undoc-members:
-   :show-inheritance:
+    :members:
+    :undoc-members:
+    :show-inheritance:
 
 seldon\_core.seldon\_client module
 ----------------------------------
 
 .. automodule:: seldon_core.seldon_client
-   :members:
-   :undoc-members:
-   :show-inheritance:
+    :members:
+    :undoc-members:
+    :show-inheritance:
 
 seldon\_core.seldon\_methods module
 -----------------------------------
 
 .. automodule:: seldon_core.seldon_methods
-   :members:
-   :undoc-members:
-   :show-inheritance:
+    :members:
+    :undoc-members:
+    :show-inheritance:
 
 seldon\_core.serving\_test\_gen module
 --------------------------------------
 
 .. automodule:: seldon_core.serving_test_gen
-   :members:
-   :undoc-members:
-   :show-inheritance:
+    :members:
+    :undoc-members:
+    :show-inheritance:
 
 seldon\_core.storage module
 ---------------------------
 
 .. automodule:: seldon_core.storage
-   :members:
-   :undoc-members:
-   :show-inheritance:
+    :members:
+    :undoc-members:
+    :show-inheritance:
 
 seldon\_core.user\_model module
 -------------------------------
 
 .. automodule:: seldon_core.user_model
-   :members:
-   :undoc-members:
-   :show-inheritance:
+    :members:
+    :undoc-members:
+    :show-inheritance:
 
 seldon\_core.utils module
 -------------------------
 
 .. automodule:: seldon_core.utils
-   :members:
-   :undoc-members:
-   :show-inheritance:
+    :members:
+    :undoc-members:
+    :show-inheritance:
 
 seldon\_core.version module
 ---------------------------
 
 .. automodule:: seldon_core.version
-   :members:
-   :undoc-members:
-   :show-inheritance:
+    :members:
+    :undoc-members:
+    :show-inheritance:
 
 seldon\_core.wrapper module
 ---------------------------
 
 .. automodule:: seldon_core.wrapper
-   :members:
-   :undoc-members:
-   :show-inheritance:
+    :members:
+    :undoc-members:
+    :show-inheritance:
+
 
diff --git a/engine/src/main/java/io/seldon/engine/service/InternalPredictionService.java b/engine/src/main/java/io/seldon/engine/service/InternalPredictionService.java
index 129ddb2f47..27b9917bc1 100644
--- a/engine/src/main/java/io/seldon/engine/service/InternalPredictionService.java
+++ b/engine/src/main/java/io/seldon/engine/service/InternalPredictionService.java
@@ -247,6 +247,7 @@ else if (state.type == PredictiveUnitType.MODEL)
     
     public SeldonMessage transformInput(SeldonMessage input, PredictiveUnitState state) throws InvalidProtocolBufferException
     {
+    	logger.info("Calling grpc for transform-input");
     	final Endpoint endpoint = state.endpoint;
 		switch (endpoint.getType()){
 			case REST:
@@ -267,11 +268,20 @@ public SeldonMessage transformInput(SeldonMessage input, PredictiveUnitState sta
 							.withMaxOutboundMessageSize(grpcMaxMessageSize);
 						return genStub.transformInput(input);
 					case MODEL:
-						ModelBlockingStub modelStub = ModelGrpc.newBlockingStub(grpcChannelHandler.get(endpoint))
-							.withDeadlineAfter(grpcReadTimeout, TimeUnit.MILLISECONDS)
-							.withMaxInboundMessageSize(grpcMaxMessageSize)
-							.withMaxOutboundMessageSize(grpcMaxMessageSize);
-						return modelStub.predict(input);
+						try
+						{
+							ModelBlockingStub modelStub = ModelGrpc.newBlockingStub(grpcChannelHandler.get(endpoint))
+								.withDeadlineAfter(grpcReadTimeout, TimeUnit.MILLISECONDS)
+								.withMaxInboundMessageSize(grpcMaxMessageSize)
+								.withMaxOutboundMessageSize(grpcMaxMessageSize);
+							logger.info(modelStub.getCallOptions().toString());
+							return modelStub.predict(input);
+						}
+						catch (Exception e)
+						{
+							logger.error("grpc exception ",e);
+							throw e;
+						}
 					case TRANSFORMER:
 						TransformerBlockingStub transformerStub = TransformerGrpc.newBlockingStub(grpcChannelHandler.get(endpoint))
 						.withDeadlineAfter(grpcReadTimeout, TimeUnit.MILLISECONDS)
diff --git a/integrations/tfserving/Makefile b/integrations/tfserving/Makefile
index b5997b69b1..a4117f0a57 100644
--- a/integrations/tfserving/Makefile
+++ b/integrations/tfserving/Makefile
@@ -1,15 +1,15 @@
-IMAGE_VERSION=0.6
+IMAGE_VERSION=0.7
 IMAGE_NAME = docker.io/seldonio/tfserving-proxy
 
 SELDON_CORE_DIR=../../..
 
 .PHONY: build_rest
 build_rest: 
-	s2i build -E environment_rest . seldonio/seldon-core-s2i-python3:0.11-SNAPSHOT $(IMAGE_NAME)_rest:$(IMAGE_VERSION)
+	s2i build -E environment_rest . seldonio/seldon-core-s2i-python3:0.12-SNAPSHOT $(IMAGE_NAME)_rest:$(IMAGE_VERSION)
 
 .PHONY: build_grpc
 build_grpc: 
-	s2i build -E environment_grpc . seldonio/seldon-core-s2i-python3:0.11-SNAPSHOT $(IMAGE_NAME)_grpc:$(IMAGE_VERSION)
+	s2i build -E environment_grpc . seldonio/seldon-core-s2i-python3:0.12-SNAPSHOT $(IMAGE_NAME)_grpc:$(IMAGE_VERSION)
 
 
 push_to_dockerhub_rest:
diff --git a/integrations/tfserving/TfServingProxy.py b/integrations/tfserving/TfServingProxy.py
index 0706a5a1c6..7d38beacdd 100644
--- a/integrations/tfserving/TfServingProxy.py
+++ b/integrations/tfserving/TfServingProxy.py
@@ -34,7 +34,11 @@ def __init__(
         log.debug("grpc_endpoint:",grpc_endpoint)
         if not grpc_endpoint is None:
             self.grpc = True
-            channel = grpc.insecure_channel(grpc_endpoint)
+            max_msg = 1000000000
+            options = [('grpc.max_message_length', max_msg),
+                       ('grpc.max_send_message_length', max_msg),
+                       ('grpc.max_receive_message_length', max_msg)]
+            channel = grpc.insecure_channel(grpc_endpoint,options)
             self.stub = prediction_service_pb2_grpc.PredictionServiceStub(channel)
         else:
             self.grpc = False
@@ -80,13 +84,10 @@ def predict_grpc(self,request):
                     data_arr.tolist(),
                     shape=data_arr.shape))
             result = self.stub.Predict(tfrequest)
-            result_arr = numpy.array(result.outputs[self.model_output].float_val)
-            if len(result_arr.shape) == 1:
-                result_arr = numpy.expand_dims(result_arr, axis=0)
-            class_names = []
-            data = array_to_grpc_datadef(
-                default_data_type, result_arr, class_names)
-            return prediction_pb2.SeldonMessage(data=data)
+            datadef = prediction_pb2.DefaultData(
+                tftensor=result.outputs[self.model_output]
+            )
+            return prediction_pb2.SeldonMessage(data=datadef)
 
     def predict(self, X, features_names=[]):
         """
diff --git a/notebooks/explainer_examples.ipynb b/notebooks/explainer_examples.ipynb
new file mode 100644
index 0000000000..d2d63a957b
--- /dev/null
+++ b/notebooks/explainer_examples.ipynb
@@ -0,0 +1,800 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Example Model Servers with Seldon"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Prerequistes\n",
+    "You will need\n",
+    " - [Git clone of Seldon Core](https://github.com/SeldonIO/seldon-core)\n",
+    " - A running Kubernetes cluster with kubectl authenticated\n",
+    " - [seldon-core Python package](https://pypi.org/project/seldon-core/) (```pip install seldon-core>=0.2.6.1```)\n",
+    " - [Helm client](https://helm.sh/)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Creating a Kubernetes Cluster\n",
+    "\n",
+    "Follow the [Kubernetes documentation to create a cluster](https://kubernetes.io/docs/setup/).\n",
+    "\n",
+    "Once created ensure ```kubectl``` is authenticated against the running cluster."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Setup"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!kubectl create namespace seldon"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!kubectl config set-context $(kubectl config current-context) --namespace=seldon"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!kubectl create clusterrolebinding kube-system-cluster-admin --clusterrole=cluster-admin --serviceaccount=kube-system:default"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Install Helm"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!kubectl -n kube-system create sa tiller\n",
+    "!kubectl create clusterrolebinding tiller --clusterrole cluster-admin --serviceaccount=kube-system:tiller\n",
+    "!helm init --service-account tiller"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!kubectl rollout status deploy/tiller-deploy -n kube-system"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Start seldon-core"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "!helm install ../helm-charts/seldon-core-operator --name seldon-core  --set image.pullPolicy=Never --set usageMetrics.enabled=true --namespace seldon-system"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!kubectl rollout status statefulset.apps/seldon-operator-controller-manager -n seldon-system"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Setup Ingress\n",
+    "Please note: There are reported gRPC issues with ambassador (see https://github.com/SeldonIO/seldon-core/issues/473)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!helm install stable/ambassador --name ambassador --set crds.keep=false"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!kubectl rollout status deployment.apps/ambassador"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Port Forward to Ambassador\n",
+    "\n",
+    "```\n",
+    "kubectl port-forward $(kubectl get pods -n seldon -l app.kubernetes.io/name=ambassador -o jsonpath='{.items[0].metadata.name}') -n seldon 8003:8080\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Income Prediction Model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\u001b[34;01mapiVersion\u001b[39;49;00m: machinelearning.seldon.io/v1alpha2\r\n",
+      "\u001b[34;01mkind\u001b[39;49;00m: SeldonDeployment\r\n",
+      "\u001b[34;01mmetadata\u001b[39;49;00m:\r\n",
+      "  \u001b[34;01mname\u001b[39;49;00m: income\r\n",
+      "\u001b[34;01mspec\u001b[39;49;00m:\r\n",
+      "  \u001b[34;01mname\u001b[39;49;00m: income\r\n",
+      "  \u001b[34;01mpredictors\u001b[39;49;00m:\r\n",
+      "  - \u001b[34;01mgraph\u001b[39;49;00m:\r\n",
+      "      \u001b[34;01mchildren\u001b[39;49;00m: []\r\n",
+      "      \u001b[34;01mimplementation\u001b[39;49;00m: SKLEARN_SERVER\r\n",
+      "      \u001b[34;01mmodelUri\u001b[39;49;00m: gs://seldon-models/sklearn/income/model\r\n",
+      "      \u001b[34;01mname\u001b[39;49;00m: classifier\r\n",
+      "    \u001b[34;01mexplainer\u001b[39;49;00m:\r\n",
+      "      \u001b[34;01mtype\u001b[39;49;00m: anchor_tabular\r\n",
+      "      \u001b[34;01mmodelUri\u001b[39;49;00m: gs://seldon-models/sklearn/income/explainer\r\n",
+      "    \u001b[34;01mname\u001b[39;49;00m: default\r\n",
+      "    \u001b[34;01mreplicas\u001b[39;49;00m: 1\r\n"
+     ]
+    }
+   ],
+   "source": [
+    "!pygmentize resources/income_explainer.yaml"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "seldondeployment.machinelearning.seldon.io/income created\r\n"
+     ]
+    }
+   ],
+   "source": [
+    "!kubectl apply -f resources/income_explainer.yaml"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Waiting for deployment \"income-default-4903e3c\" rollout to finish: 0 of 1 updated replicas are available...\n",
+      "deployment \"income-default-4903e3c\" successfully rolled out\n"
+     ]
+    }
+   ],
+   "source": [
+    "!kubectl rollout status deploy/income-default-4903e3c"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from seldon_core.seldon_client import SeldonClient\n",
+    "import numpy as np\n",
+    "sc = SeldonClient(deployment_name=\"income\",namespace=\"seldon\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Success:True message:\n",
+      "Request:\n",
+      "data {\n",
+      "  tensor {\n",
+      "    shape: 1\n",
+      "    shape: 12\n",
+      "    values: 39.0\n",
+      "    values: 7.0\n",
+      "    values: 1.0\n",
+      "    values: 1.0\n",
+      "    values: 1.0\n",
+      "    values: 1.0\n",
+      "    values: 4.0\n",
+      "    values: 1.0\n",
+      "    values: 2174.0\n",
+      "    values: 0.0\n",
+      "    values: 40.0\n",
+      "    values: 9.0\n",
+      "  }\n",
+      "}\n",
+      "\n",
+      "Response:\n",
+      "meta {\n",
+      "  puid: \"8qs8ieo9jp79i5bjs63nc1n6bk\"\n",
+      "  requestPath {\n",
+      "    key: \"classifier\"\n",
+      "    value: \"seldonio/sklearnserver_rest:0.2\"\n",
+      "  }\n",
+      "}\n",
+      "data {\n",
+      "  names: \"t:0\"\n",
+      "  names: \"t:1\"\n",
+      "  tensor {\n",
+      "    shape: 1\n",
+      "    shape: 2\n",
+      "    values: 1.0\n",
+      "    values: 0.0\n",
+      "  }\n",
+      "}\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "data = np.array([[39, 7, 1, 1, 1, 1, 4, 1, 2174, 0, 40, 9]])\n",
+    "r = sc.predict(gateway=\"ambassador\",transport=\"rest\",data=data)\n",
+    "print(r)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "['Marital Status = Never-Married', 'Hours per week <= 40.00']\n"
+     ]
+    }
+   ],
+   "source": [
+    "data = np.array([[39, 7, 1, 1, 1, 1, 4, 1, 2174, 0, 40, 9]])\n",
+    "explanation = sc.explain(deployment_name=\"income\",gateway=\"ambassador\",transport=\"rest\",data=data)\n",
+    "print(explanation[\"names\"])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "seldondeployment.machinelearning.seldon.io \"income\" deleted\r\n"
+     ]
+    }
+   ],
+   "source": [
+    "!kubectl delete -f resources/income_explainer.yaml"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Movie Sentiment Model\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\u001b[34;01mapiVersion\u001b[39;49;00m: machinelearning.seldon.io/v1alpha2\r\n",
+      "\u001b[34;01mkind\u001b[39;49;00m: SeldonDeployment\r\n",
+      "\u001b[34;01mmetadata\u001b[39;49;00m:\r\n",
+      "  \u001b[34;01mname\u001b[39;49;00m: movie\r\n",
+      "\u001b[34;01mspec\u001b[39;49;00m:\r\n",
+      "  \u001b[34;01mname\u001b[39;49;00m: movie\r\n",
+      "  \u001b[34;01mpredictors\u001b[39;49;00m:\r\n",
+      "  - \u001b[34;01mgraph\u001b[39;49;00m:\r\n",
+      "      \u001b[34;01mchildren\u001b[39;49;00m: []\r\n",
+      "      \u001b[34;01mimplementation\u001b[39;49;00m: SKLEARN_SERVER\r\n",
+      "      \u001b[34;01mmodelUri\u001b[39;49;00m: gs://seldon-models/sklearn/moviesentiment\r\n",
+      "      \u001b[34;01mname\u001b[39;49;00m: classifier\r\n",
+      "    \u001b[34;01mexplainer\u001b[39;49;00m:\r\n",
+      "      \u001b[34;01mtype\u001b[39;49;00m: anchor_text\r\n",
+      "    \u001b[34;01mname\u001b[39;49;00m: default\r\n",
+      "    \u001b[34;01mreplicas\u001b[39;49;00m: 1\r\n"
+     ]
+    }
+   ],
+   "source": [
+    "!pygmentize resources/moviesentiment_explainer.yaml"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "seldondeployment.machinelearning.seldon.io/movie created\r\n"
+     ]
+    }
+   ],
+   "source": [
+    "!kubectl apply -f resources/moviesentiment_explainer.yaml"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Waiting for deployment \"movie-default-4903e3c\" rollout to finish: 0 of 1 updated replicas are available...\n",
+      "deployment \"movie-default-4903e3c\" successfully rolled out\n"
+     ]
+    }
+   ],
+   "source": [
+    "!kubectl rollout status deploy/movie-default-4903e3c"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from seldon_core.seldon_client import SeldonClient\n",
+    "import numpy as np\n",
+    "sc = SeldonClient(deployment_name=\"movie\",namespace=\"seldon\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Success:True message:\n",
+      "Request:\n",
+      "data {\n",
+      "  ndarray {\n",
+      "    values {\n",
+      "      string_value: \"this film has great actors\"\n",
+      "    }\n",
+      "  }\n",
+      "}\n",
+      "\n",
+      "Response:\n",
+      "meta {\n",
+      "  puid: \"re1drvdqoppisg1cl42aib3abc\"\n",
+      "  requestPath {\n",
+      "    key: \"classifier\"\n",
+      "    value: \"seldonio/sklearnserver_rest:0.2\"\n",
+      "  }\n",
+      "}\n",
+      "data {\n",
+      "  names: \"t:0\"\n",
+      "  names: \"t:1\"\n",
+      "  ndarray {\n",
+      "    values {\n",
+      "      list_value {\n",
+      "        values {\n",
+      "          number_value: 0.21266916924914636\n",
+      "        }\n",
+      "        values {\n",
+      "          number_value: 0.7873308307508536\n",
+      "        }\n",
+      "      }\n",
+      "    }\n",
+      "  }\n",
+      "}\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "data = np.array(['this film has great actors'])\n",
+    "r = sc.predict(gateway=\"ambassador\",transport=\"rest\",data=data,payload_type='ndarray')\n",
+    "print(r)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'names': ['great'], 'precision': 1.0, 'coverage': 0.5007, 'raw': {'feature': [3], 'mean': [1.0], 'precision': [1.0], 'coverage': [0.5007], 'examples': [{'covered': [['this film UNK great UNK'], ['UNK film has great actors'], ['UNK film UNK great actors'], ['this UNK has great UNK'], ['this film UNK great UNK'], ['this UNK has great UNK'], ['UNK UNK UNK great actors'], ['UNK film has great actors'], ['UNK film UNK great UNK'], ['UNK UNK UNK great actors']], 'covered_true': [['UNK film UNK great UNK'], ['UNK UNK has great UNK'], ['UNK UNK UNK great actors'], ['UNK UNK has great UNK'], ['this UNK UNK great UNK'], ['UNK film UNK great actors'], ['this UNK has great UNK'], ['this UNK UNK great UNK'], ['UNK film has great actors'], ['this film UNK great UNK']], 'covered_false': [], 'uncovered_true': [], 'uncovered_false': []}], 'all_precision': 0, 'num_preds': 1000101, 'names': ['great'], 'positions': [14], 'instance': 'this film has great actors', 'prediction': 1}}\n"
+     ]
+    }
+   ],
+   "source": [
+    "data = np.array(['this film has great actors'])\n",
+    "explanation = sc.explain(deployment_name=\"movie\",gateway=\"ambassador\",transport=\"rest\",data=data,payload_type='ndarray')\n",
+    "print(explanation)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "seldondeployment.machinelearning.seldon.io \"movie\" deleted\r\n"
+     ]
+    }
+   ],
+   "source": [
+    "!kubectl delete -f resources/moviesentiment_explainer.yaml"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Imagenet Model\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 61,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\u001b[34;01mapiVersion\u001b[39;49;00m: machinelearning.seldon.io/v1alpha2\r\n",
+      "\u001b[34;01mkind\u001b[39;49;00m: SeldonDeployment\r\n",
+      "\u001b[34;01mmetadata\u001b[39;49;00m:\r\n",
+      "  \u001b[34;01mname\u001b[39;49;00m: image\r\n",
+      "\u001b[34;01mspec\u001b[39;49;00m:\r\n",
+      "  \u001b[34;01mannotations\u001b[39;49;00m:\r\n",
+      "    \u001b[34;01mseldon.io/rest-read-timeout\u001b[39;49;00m: \u001b[33m\"\u001b[39;49;00m\u001b[33m10000000\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m\r\n",
+      "    \u001b[34;01mseldon.io/grpc-read-timeout\u001b[39;49;00m: \u001b[33m\"\u001b[39;49;00m\u001b[33m10000000\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m\r\n",
+      "    \u001b[34;01mseldon.io/grpc-max-message-size\u001b[39;49;00m: \u001b[33m\"\u001b[39;49;00m\u001b[33m1000000000\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m\r\n",
+      "  \u001b[34;01mname\u001b[39;49;00m: image\r\n",
+      "  \u001b[34;01mpredictors\u001b[39;49;00m:\r\n",
+      "  - \u001b[34;01mgraph\u001b[39;49;00m:\r\n",
+      "      \u001b[34;01mchildren\u001b[39;49;00m: []\r\n",
+      "      \u001b[34;01mimplementation\u001b[39;49;00m: TENSORFLOW_SERVER\r\n",
+      "      \u001b[34;01mmodelUri\u001b[39;49;00m: gs://seldon-models/tfserving/imagenet/model\r\n",
+      "      \u001b[34;01mname\u001b[39;49;00m: classifier\r\n",
+      "      \u001b[34;01mendpoint\u001b[39;49;00m:\r\n",
+      "        \u001b[34;01mtype\u001b[39;49;00m: GRPC\r\n",
+      "      \u001b[34;01mparameters\u001b[39;49;00m:\r\n",
+      "        - \u001b[34;01mname\u001b[39;49;00m: model_name\r\n",
+      "          \u001b[34;01mtype\u001b[39;49;00m: STRING\r\n",
+      "          \u001b[34;01mvalue\u001b[39;49;00m: classifier\r\n",
+      "        - \u001b[34;01mname\u001b[39;49;00m: model_input\r\n",
+      "          \u001b[34;01mtype\u001b[39;49;00m: STRING\r\n",
+      "          \u001b[34;01mvalue\u001b[39;49;00m: input_image\r\n",
+      "        - \u001b[34;01mname\u001b[39;49;00m: model_output\r\n",
+      "          \u001b[34;01mtype\u001b[39;49;00m: STRING\r\n",
+      "          \u001b[34;01mvalue\u001b[39;49;00m: predictions/Softmax:0\r\n",
+      "    \u001b[34;01mengineResources\u001b[39;49;00m:\r\n",
+      "      \u001b[34;01mrequests\u001b[39;49;00m:\r\n",
+      "        \u001b[34;01mmemory\u001b[39;49;00m: 1Gi\r\n",
+      "    \u001b[34;01mexplainer\u001b[39;49;00m:\r\n",
+      "      \u001b[34;01mtype\u001b[39;49;00m: anchor_images\r\n",
+      "      \u001b[34;01mmodelUri\u001b[39;49;00m: gs://seldon-models/tfserving/imagenet/explainer\r\n",
+      "    \u001b[34;01mname\u001b[39;49;00m: default\r\n",
+      "    \u001b[34;01mreplicas\u001b[39;49;00m: 1\r\n"
+     ]
+    }
+   ],
+   "source": [
+    "!pygmentize resources/imagenet_explainer_grpc.yaml"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 64,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "seldondeployment.machinelearning.seldon.io/image created\r\n"
+     ]
+    }
+   ],
+   "source": [
+    "!kubectl apply -f resources/imagenet_explainer_grpc.yaml"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 65,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Waiting for deployment \"image-default-117dcdf\" rollout to finish: 0 of 1 updated replicas are available...\n",
+      "deployment \"image-default-117dcdf\" successfully rolled out\n"
+     ]
+    }
+   ],
+   "source": [
+    "!kubectl rollout status deploy/image-default-117dcdf"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 66,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import matplotlib\n",
+    "%matplotlib inline\n",
+    "import matplotlib.pyplot as plt\n",
+    "from tensorflow.keras.applications.inception_v3 import InceptionV3, preprocess_input, decode_predictions\n",
+    "import alibi\n",
+    "from alibi.datasets import fetch_imagenet\n",
+    "import numpy as np\n",
+    "\n",
+    "def get_image_data():\n",
+    "    category = 'Persian cat'\n",
+    "    image_shape = (299, 299, 3)\n",
+    "    data, _ = fetch_imagenet(category, nb_images=10, target_size=image_shape[:2], seed=2,\n",
+    "                                  return_X_y=True)\n",
+    "    return data\n",
+    "\n",
+    "data = get_image_data()\n",
+    "images = preprocess_input(data)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 67,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from seldon_core.seldon_client import SeldonClient\n",
+    "import numpy as np\n",
+    "sc = SeldonClient(deployment_name=\"image\",namespace=\"seldon\",grpc_max_send_message_length= 27 * 1024 * 1024,grpc_max_receive_message_length= 27 * 1024 * 1024)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 72,
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.image.AxesImage at 0x7fe598612860>"
+      ]
+     },
+     "execution_count": 72,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import tensorflow as tf\n",
+    "req = images[0:1]\n",
+    "r = sc.predict(gateway=\"ambassador\",transport=\"grpc\",data=req,payload_type='tftensor')\n",
+    "preds = tf.make_ndarray(r.response.data.tftensor)\n",
+    "\n",
+    "label = decode_predictions(preds, top=1)\n",
+    "plt.title(label[0])\n",
+    "plt.imshow(data[0])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 73,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "req = np.expand_dims(images[0], axis=0)\n",
+    "explanation = sc.explain(deployment_name=\"image\",gateway=\"ambassador\",transport=\"rest\",data=req)\n",
+    "exp_arr = np.array(explanation['anchor'])\n",
+    "\n",
+    "f, axarr = plt.subplots(1, 2)\n",
+    "axarr[0].imshow(data[0])\n",
+    "axarr[1].imshow(explanation['anchor'])\n",
+    "plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 74,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "seldondeployment.machinelearning.seldon.io \"image\" deleted\r\n"
+     ]
+    }
+   ],
+   "source": [
+    "!kubectl delete -f resources/imagenet_explainer_grpc.yaml"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "anaconda-cloud": {},
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.6.8"
+  },
+  "varInspector": {
+   "cols": {
+    "lenName": 16,
+    "lenType": 16,
+    "lenVar": 40
+   },
+   "kernels_config": {
+    "python": {
+     "delete_cmd_postfix": "",
+     "delete_cmd_prefix": "del ",
+     "library": "var_list.py",
+     "varRefreshCmd": "print(var_dic_list())"
+    },
+    "r": {
+     "delete_cmd_postfix": ") ",
+     "delete_cmd_prefix": "rm(",
+     "library": "var_list.r",
+     "varRefreshCmd": "cat(var_dic_list()) "
+    }
+   },
+   "types_to_exclude": [
+    "module",
+    "function",
+    "builtin_function_or_method",
+    "instance",
+    "_Feature"
+   ],
+   "window_display": false
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 1
+}
diff --git a/notebooks/resources/imagenet_explainer.yaml b/notebooks/resources/imagenet_explainer.yaml
new file mode 100644
index 0000000000..6167932ba7
--- /dev/null
+++ b/notebooks/resources/imagenet_explainer.yaml
@@ -0,0 +1,22 @@
+apiVersion: machinelearning.seldon.io/v1alpha2
+kind: SeldonDeployment
+metadata:
+  name: image
+spec:
+  annotations:
+    seldon.io/rest-read-timeout: "10000000"
+  name: image
+  predictors:
+  - graph:
+      children: []
+      implementation: TENSORFLOW_SERVER
+      modelUri: gs://seldon-models/tfserving/imagenet/model
+      name: classifier
+    engineResources:
+      requests:
+        memory: 1Gi
+    explainer:
+      type: anchor_images
+      modelUri: gs://seldon-models/tfserving/imagenet/explainer
+    name: default
+    replicas: 1
diff --git a/notebooks/resources/imagenet_explainer_grpc.yaml b/notebooks/resources/imagenet_explainer_grpc.yaml
new file mode 100644
index 0000000000..7ed4c78dde
--- /dev/null
+++ b/notebooks/resources/imagenet_explainer_grpc.yaml
@@ -0,0 +1,36 @@
+apiVersion: machinelearning.seldon.io/v1alpha2
+kind: SeldonDeployment
+metadata:
+  name: image
+spec:
+  annotations:
+    seldon.io/rest-read-timeout: "10000000"
+    seldon.io/grpc-read-timeout: "10000000"
+    seldon.io/grpc-max-message-size: "1000000000"
+  name: image
+  predictors:
+  - graph:
+      children: []
+      implementation: TENSORFLOW_SERVER
+      modelUri: gs://seldon-models/tfserving/imagenet/model
+      name: classifier
+      endpoint:
+        type: GRPC
+      parameters:
+        - name: model_name
+          type: STRING
+          value: classifier
+        - name: model_input
+          type: STRING
+          value: input_image
+        - name: model_output
+          type: STRING
+          value: predictions/Softmax:0
+    engineResources:
+      requests:
+        memory: 1Gi
+    explainer:
+      type: anchor_images
+      modelUri: gs://seldon-models/tfserving/imagenet/explainer
+    name: default
+    replicas: 1
diff --git a/notebooks/resources/income_explainer.yaml b/notebooks/resources/income_explainer.yaml
new file mode 100644
index 0000000000..c54a6529dd
--- /dev/null
+++ b/notebooks/resources/income_explainer.yaml
@@ -0,0 +1,17 @@
+apiVersion: machinelearning.seldon.io/v1alpha2
+kind: SeldonDeployment
+metadata:
+  name: income
+spec:
+  name: income
+  predictors:
+  - graph:
+      children: []
+      implementation: SKLEARN_SERVER
+      modelUri: gs://seldon-models/sklearn/income/model
+      name: classifier
+    explainer:
+      type: anchor_tabular
+      modelUri: gs://seldon-models/sklearn/income/explainer
+    name: default
+    replicas: 1
diff --git a/notebooks/resources/moviesentiment_explainer.yaml b/notebooks/resources/moviesentiment_explainer.yaml
new file mode 100644
index 0000000000..5acc3b7901
--- /dev/null
+++ b/notebooks/resources/moviesentiment_explainer.yaml
@@ -0,0 +1,16 @@
+apiVersion: machinelearning.seldon.io/v1alpha2
+kind: SeldonDeployment
+metadata:
+  name: movie
+spec:
+  name: movie
+  predictors:
+  - graph:
+      children: []
+      implementation: SKLEARN_SERVER
+      modelUri: gs://seldon-models/sklearn/moviesentiment
+      name: classifier
+    explainer:
+      type: anchor_text
+    name: default
+    replicas: 1
diff --git a/python/seldon_core/seldon_client.py b/python/seldon_core/seldon_client.py
index 8453d42f02..99f94521db 100644
--- a/python/seldon_core/seldon_client.py
+++ b/python/seldon_core/seldon_client.py
@@ -197,7 +197,7 @@ def predict(self, gateway: str = None, transport: str = None, deployment_name: s
                 gateway_endpoint: str = None, microservice_endpoint: str = None,
                 method: str = None, shape: Tuple = (1, 1), namespace: str = None, data: np.ndarray = None,
                 bin_data: Union[bytes, bytearray] = None, str_data: str = None, names: Iterable[str] = None,
-                gateway_prefix: str = None, headers: Dict = None) -> SeldonClientPrediction:
+                gateway_prefix: str = None, headers: Dict = None, http_path: str = None) -> SeldonClientPrediction:
         """
 
         Parameters
@@ -240,6 +240,8 @@ def predict(self, gateway: str = None, transport: str = None, deployment_name: s
            prefix path for gateway URL endpoint
         headers
            Headers to add to request
+        http_path:
+           Custom http path for predict call to use
 
         Returns
         -------
@@ -252,7 +254,7 @@ def predict(self, gateway: str = None, transport: str = None, deployment_name: s
                               microservice_endpoint=microservice_endpoint, method=method, shape=shape,
                               namespace=namespace, names=names,
                               data=data, bin_data=bin_data, str_data=str_data,
-                              gateway_prefix=gateway_prefix, headers=headers)
+                              gateway_prefix=gateway_prefix, headers=headers, http_path=http_path)
         self._validate_args(**k)
         if k["gateway"] == "ambassador" or k["gateway"] == "istio":
             if k["transport"] == "rest":
@@ -348,6 +350,84 @@ def feedback(self, prediction_request: prediction_pb2.SeldonMessage = None,
         else:
             raise SeldonClientException("Unknown gateway " + k["gateway"])
 
+    def explain(self, gateway: str = None, transport: str = None, deployment_name: str = None,
+                payload_type: str = None,
+                seldon_rest_endpoint: str = None, seldon_grpc_endpoint: str = None,
+                gateway_endpoint: str = None, microservice_endpoint: str = None,
+                method: str = None, shape: Tuple = (1, 1), namespace: str = None,
+                data: np.ndarray = None,
+                bin_data: Union[bytes, bytearray] = None, str_data: str = None,
+                names: Iterable[str] = None,
+                gateway_prefix: str = None, headers: Dict = None,
+                http_path: str = None) -> Dict:
+        """
+
+        Parameters
+        ----------
+        gateway
+           API Gateway - either ambassador, istio or seldon
+        transport
+           API transport - grpc or rest
+        namespace
+           k8s namespace of running deployment
+        deployment_name
+           name of seldon deployment
+        payload_type
+           type of payload - tensor, ndarray or tftensor
+        seldon_rest_endpoint
+           REST endpoint to seldon api server
+        seldon_grpc_endpoint
+           gRPC endpoint to seldon api server
+        gateway_endpoint
+           Gateway endpoint
+        microservice_endpoint
+           Running microservice endpoint
+        grpc_max_send_message_length
+           Max grpc send message size in bytes
+        grpc_max_receive_message_length
+           Max grpc receive message size in bytes
+        data
+           Numpy Array Payload to send
+        bin_data
+           Binary payload to send - will override data
+        str_data
+           String payload to send - will override data
+        names
+           Column names
+        gateway_prefix
+           prefix path for gateway URL endpoint
+        headers
+           Headers to add to request
+        http_path:
+           Custom http path for predict call to use
+
+        Returns
+        -------
+
+        """
+        k = self._gather_args(gateway=gateway, transport=transport, deployment_name=deployment_name,
+                              payload_type=payload_type, seldon_rest_endpoint=seldon_rest_endpoint,
+                              seldon_grpc_endpoint=seldon_grpc_endpoint,
+                              gateway_endpoint=gateway_endpoint,
+                              microservice_endpoint=microservice_endpoint, method=method,
+                              shape=shape,
+                              namespace=namespace, names=names,
+                              data=data, bin_data=bin_data, str_data=str_data,
+                              gateway_prefix=gateway_prefix, headers=headers, http_path=http_path)
+        self._validate_args(**k)
+        if k["gateway"] == "ambassador" or k["gateway"] == "istio":
+            if k["transport"] == "rest":
+                return explain_predict_gateway(**k)
+            elif k["transport"] == "grpc":
+                raise SeldonClientException("gRPC not supported for explain")
+            else:
+                raise SeldonClientException("Unknown transport " + k["transport"])
+        else:
+            raise SeldonClientException("Unknown gateway " + k["gateway"])
+
+
+
+
     def microservice(self, gateway: str = None, transport: str = None, deployment_name: str = None,
                      payload_type: str = None, oauth_key: str = None, oauth_secret: str = None,
                      seldon_rest_endpoint: str = None, seldon_grpc_endpoint: str = None,
@@ -1031,7 +1111,7 @@ def rest_predict_gateway(deployment_name: str, namespace: str = None, gateway_en
                          payload_type: str = "tensor",
                          bin_data: Union[bytes, bytearray] = None, str_data: str = None,
                          names: Iterable[str] = None, call_credentials: SeldonCallCredentials = None,
-                         channel_credentials: SeldonChannelCredentials= None,
+                         channel_credentials: SeldonChannelCredentials= None, http_path: str = None,
                          **kwargs) -> SeldonClientPrediction:
     """
     REST request to Gateway Ingress
@@ -1064,6 +1144,8 @@ def rest_predict_gateway(deployment_name: str, namespace: str = None, gateway_en
        Call credentials - see SeldonCallCredentials
     channel_credentials
        Channel credentials - see SeldonChannelCredentials
+    http_path
+       Custom http path
 
     Returns
     -------
@@ -1092,13 +1174,16 @@ def rest_predict_gateway(deployment_name: str, namespace: str = None, gateway_en
         if not call_credentials is None:
             if not call_credentials.token is None:
                 req_headers["X-Auth-Token"] = call_credentials.token
-    if gateway_prefix is None:
-        if namespace is None:
-            url = scheme + "://" + gateway_endpoint + "/seldon/" + deployment_name + "/api/v0.1/predictions"
-        else:
-            url = scheme+"://" + gateway_endpoint + "/seldon/" + namespace + "/" + deployment_name + "/api/v0.1/predictions"
+    if http_path is not None:
+        url = url = scheme+"://" + gateway_endpoint + "/seldon/" + namespace + "/" + deployment_name + http_path
     else:
-        url = scheme+"://" + gateway_endpoint + gateway_prefix + "/api/v0.1/predictions"
+        if gateway_prefix is None:
+            if namespace is None:
+                url = scheme + "://" + gateway_endpoint + "/seldon/" + deployment_name + "/api/v0.1/predictions"
+            else:
+                url = scheme+"://" + gateway_endpoint + "/seldon/" + namespace + "/" + deployment_name + "/api/v0.1/predictions"
+        else:
+            url = scheme+"://" + gateway_endpoint + gateway_prefix + "/api/v0.1/predictions"
     verify = True
     cert = None
     if not channel_credentials is None:
@@ -1134,6 +1219,107 @@ def rest_predict_gateway(deployment_name: str, namespace: str = None, gateway_en
     except Exception as e:
         return SeldonClientPrediction(request, None, False, str(e))
 
+
+def explain_predict_gateway(deployment_name: str, namespace: str = None, gateway_endpoint: str = "localhost:8003",
+                         shape: Tuple[int, int] = (1, 1),
+                         data: np.ndarray = None, headers: Dict = None, gateway_prefix: str = None,
+                         payload_type: str = "tensor",
+                         bin_data: Union[bytes, bytearray] = None, str_data: str = None,
+                         names: Iterable[str] = None, call_credentials: SeldonCallCredentials = None,
+                         channel_credentials: SeldonChannelCredentials= None, http_path: str = None,
+                         **kwargs) -> Dict:
+    """
+    REST explain request to Gateway Ingress
+
+    Parameters
+    ----------
+    deployment_name
+       The name of the Seldon Deployment
+    namespace
+       k8s namespace of running deployment
+    gateway_endpoint
+       The host:port of gateway
+    shape
+       The shape of the data to send
+    data
+       The numpy data to send
+    headers
+       Headers to add to request
+    gateway_prefix
+       The prefix path to add to the request
+    payload_type
+       payload - tensor, ndarray or tftensor
+    bin_data
+       Binary data to send
+    str_data
+       String data to send
+    names
+       Column names
+    call_credentials
+       Call credentials - see SeldonCallCredentials
+    channel_credentials
+       Channel credentials - see SeldonChannelCredentials
+    http_path
+       Custom http path
+
+    Returns
+    -------
+       A JSON Dict
+
+    """
+    if bin_data is not None:
+        request = prediction_pb2.SeldonMessage(binData=bin_data)
+    elif str_data is not None:
+        request = prediction_pb2.SeldonMessage(strData=str_data)
+    else:
+        if data is None:
+            data = np.random.rand(*shape)
+        datadef = array_to_grpc_datadef(payload_type, data, names=names)
+        request = prediction_pb2.SeldonMessage(data=datadef)
+    payload = seldon_message_to_json(request)
+
+    if not headers is None:
+        req_headers = headers.copy()
+    else:
+        req_headers = {}
+    if channel_credentials is None:
+        scheme = "http"
+    else:
+        scheme = "https"
+        if not call_credentials is None:
+            if not call_credentials.token is None:
+                req_headers["X-Auth-Token"] = call_credentials.token
+    if http_path is not None:
+        url = url = scheme+"://" + gateway_endpoint + "/seldon/" + namespace + "/" + deployment_name + http_path
+    else:
+        if gateway_prefix is None:
+            if namespace is None:
+                url = scheme + "://" + gateway_endpoint + "/seldon/" + deployment_name + "-explainer/models/" + deployment_name+ ":explain"
+            else:
+                url = scheme+"://" + gateway_endpoint + "/seldon/" + namespace + "/" + deployment_name + "-explainer/models/" + deployment_name+ ":explain"
+        else:
+            url = scheme+"://" + gateway_endpoint + gateway_prefix + + "/models/" + deployment_name+ ":explain"
+    verify = True
+    cert = None
+    if not channel_credentials is None:
+        if not channel_credentials.certificate_chain_file is None:
+            verify = channel_credentials.certificate_chain_file
+        else:
+            verify = channel_credentials.verify
+        if not channel_credentials.private_key_file is None:
+            cert = (channel_credentials.root_certificates_file, channel_credentials.private_key_file)
+    logger.debug("URL is "+url)
+    response_raw = requests.post(
+        url,
+        json=payload,
+        headers=req_headers,
+        verify=verify,
+        cert=cert)
+    if response_raw.status_code == 200:
+        return response_raw.json()
+    else:
+        return {"success":False,"response_code":response_raw.status_code}
+
 def grpc_predict_gateway(deployment_name: str, namespace: str = None, gateway_endpoint: str = "localhost:8003",
                          shape: Tuple[int, int] = (1, 1),
                          data: np.ndarray = None,
diff --git a/python/seldon_core/wrapper.py b/python/seldon_core/wrapper.py
index 9805203c53..e84a0db054 100644
--- a/python/seldon_core/wrapper.py
+++ b/python/seldon_core/wrapper.py
@@ -131,6 +131,7 @@ def get_grpc_server(user_model, annotations={}, trace_interceptor=None):
         logger.info(
             "Setting grpc max message and receive length to %d", max_msg)
         options.append(('grpc.max_message_length', max_msg))
+        options.append(('grpc.max_send_message_length', max_msg))
         options.append(('grpc.max_receive_message_length', max_msg))
 
     server = grpc.server(futures.ThreadPoolExecutor(