diff --git a/WORKSPACE b/WORKSPACE
index bca96f2d386..92cc0330b5a 100644
--- a/WORKSPACE
+++ b/WORKSPACE
@@ -11,8 +11,8 @@ load("//tensorflow_serving:repo.bzl", "tensorflow_http_archive")
 
 tensorflow_http_archive(
     name = "org_tensorflow",
-    sha256 = "cbd96914936ce3aacc39e02c2efb711f937f8ebcda888c349eab075185d7c914",
-    git_commit = "d8fac4cb80eb0c42d2550bcb720a80d29fc5f22d",
+    sha256 = "876f800cf9605375c4a05daf44bc280bcb85ef5b302a9c01592a828c61647574",
+    git_commit = "694892d4c0fba6bd4322e943f8b1483b36f1ae99",
 )
 
 # TensorFlow depends on "io_bazel_rules_closure" so we need this here.
diff --git a/tensorflow_serving/apis/BUILD b/tensorflow_serving/apis/BUILD
index 3da7d9de710..fb9c83ba68d 100644
--- a/tensorflow_serving/apis/BUILD
+++ b/tensorflow_serving/apis/BUILD
@@ -146,6 +146,20 @@ serving_proto_library(
     ],
 )
 
+serving_proto_library_py(
+    name = "prediction_log_proto_py_pb2",
+    srcs = ["prediction_log.proto"],
+    proto_library = "prediction_log_proto",
+    deps = [
+        ":classification_proto_py_pb2",
+        ":inference_proto_py_pb2",
+        ":predict_proto_py_pb2",
+        ":regression_proto_py_pb2",
+        ":session_service_proto_py_pb2",
+        "//tensorflow_serving/core:logging_proto_py_pb2",
+    ],
+)
+
 serving_proto_library(
     name = "prediction_service_proto",
     srcs = ["prediction_service.proto"],
@@ -351,6 +365,16 @@ serving_proto_library(
     ],
 )
 
+serving_proto_library_py(
+    name = "session_service_proto_py_pb2",
+    srcs = ["session_service.proto"],
+    proto_library = "session_service_proto",
+    deps = [
+        ":model_proto_py_pb2",
+        "@org_tensorflow//tensorflow/core:protos_all_py",
+    ],
+)
+
 tf_pyclif_proto_library(
     name = "regression_pyclif",
     proto_lib = ":regression_proto",
diff --git a/tensorflow_serving/config/BUILD b/tensorflow_serving/config/BUILD
index cc33650d4be..84dfe5364f6 100644
--- a/tensorflow_serving/config/BUILD
+++ b/tensorflow_serving/config/BUILD
@@ -57,6 +57,14 @@ serving_proto_library(
     ],
 )
 
+serving_proto_library_py(
+    name = "log_collector_config_proto_py_pb2",
+    srcs = ["log_collector_config.proto"],
+    proto_library = "log_collector_config_proto",
+    deps = [
+    ],
+)
+
 serving_proto_library(
     name = "logging_config_proto",
     srcs = ["logging_config.proto"],
@@ -66,3 +74,12 @@ serving_proto_library(
         ":log_collector_config_proto",
     ],
 )
+
+serving_proto_library_py(
+    name = "logging_config_proto_py_pb2",
+    srcs = ["logging_config.proto"],
+    proto_library = "logging_config_proto",
+    deps = [
+        ":log_collector_config_proto_py_pb2",
+    ],
+)
diff --git a/tensorflow_serving/core/BUILD b/tensorflow_serving/core/BUILD
index 4ec8fefcd1e..b11ab0895a4 100644
--- a/tensorflow_serving/core/BUILD
+++ b/tensorflow_serving/core/BUILD
@@ -733,6 +733,7 @@ cc_test(
 )
 
 load("//tensorflow_serving:serving.bzl", "serving_proto_library")
+load("//tensorflow_serving:serving.bzl", "serving_proto_library_py")
 
 serving_proto_library(
     name = "logging_proto",
@@ -748,6 +749,19 @@ serving_proto_library(
     ],
 )
 
+serving_proto_library_py(
+    name = "logging_proto_py_pb2",
+    srcs = ["logging.proto"],
+    proto_library = "logging_proto",
+    visibility = [
+        "//visibility:public",
+    ],
+    deps = [
+        "//tensorflow_serving/apis:model_proto_py_pb2",
+        "//tensorflow_serving/config:logging_config_proto_py_pb2",
+    ],
+)
+
 cc_library(
     name = "request_logger",
     srcs = ["request_logger.cc"],
diff --git a/tensorflow_serving/core/test_util/BUILD b/tensorflow_serving/core/test_util/BUILD
index 082dd7f14ce..b74abc10ded 100644
--- a/tensorflow_serving/core/test_util/BUILD
+++ b/tensorflow_serving/core/test_util/BUILD
@@ -26,6 +26,7 @@ cc_library(
     testonly = 1,
     srcs = ["test_main.cc"],
     linkopts = ["-lm"],
+    tags = ["keep_dep"],  # Tell build_cleaner to keep dependencies on this.
     deps = [
         "@com_google_googletest//:gtest",
         "@org_tensorflow//tensorflow/core:testlib",
diff --git a/tensorflow_serving/g3doc/api_rest.md b/tensorflow_serving/g3doc/api_rest.md
new file mode 100644
index 00000000000..760f90c6af7
--- /dev/null
+++ b/tensorflow_serving/g3doc/api_rest.md
@@ -0,0 +1,290 @@
+# RESTful API
+
+In addition to [gRPC
+APIs](https://github.com/tensorflow/serving/blob/master/tensorflow_serving/apis/prediction_service.proto)
+TensorFlow ModelServer also supports RESTful APIs for classification, regression
+and prediction on TensorFlow models. This page describes these API endpoints and
+format of request/response involved in using them.
+
+TensorFlow ModelServer running on `host:port` accepts following REST API
+requests:
+
+```
+POST http://host:port/<URI>:<VERB>
+
+URI: /v1/models/${MODEL_NAME}[/versions/${MODEL_VERSION}]
+VERB: classify|regress|predict
+```
+
+`/versions/${MODEL_VERSION}` is optional. If omitted the latest version is used.
+
+This API closely follows the gRPC version of
+[`PredictionService`](https://github.com/tensorflow/serving/blob/5369880e9143aa00d586ee536c12b04e945a977c/tensorflow_serving/apis/prediction_service.proto#L15)
+API.
+
+Examples of request URLs:
+
+```
+http://host:port/v1/models/iris:classify
+http://host:port/v1/models/mnist/versions/314:predict
+```
+
+The request and response is a JSON object. The composition of this object
+depends on the request type or verb. See the API specific sections below for
+details.
+
+In case of error, all APIs will return a JSON object in the response body with
+`error` as key and the error message as the value:
+
+```json
+{
+  "error": <error message string>
+}
+```
+
+## Classify and Regress API
+
+### Request format
+
+The request body for the `classify` and `regress` APIs must be a JSON object
+formatted as follows:
+
+```json
+{
+  // Optional: serving signature to use.
+  // If unspecifed default serving signature is used.
+  "signature_name": <string>,
+
+  // Optional: Common context shared by all examples.
+  // Features that appear here MUST NOT appear in examples (below).
+  "context": {
+    "<feature_name3>": <value>|<list>
+    "<feature_name4>": <value>|<list>
+  },
+
+  // List of Example objects
+  "examples": [
+    {
+      // Example 1
+      "<feature_name1>": <value>|<list>,
+      "<feature_name2>": <value>|<list>,
+      ...
+    },
+    {
+      // Example 2
+      "<feature_name1>": <value>|<list>,
+      "<feature_name2>": <value>|<list>,
+      ...
+    }
+    ...
+  ]
+}
+```
+
+`<value>` is a JSON number (whole or decimal) or string, and `<list>` is a list
+of such values. See [Encoding binary values](#encoding-binary-values) section
+below for details on how to represent a binary (stream of bytes) value. This
+format is similar to gRPC's `ClassificationRequest` and `RegressionRequest`
+protos. Both versions accept list of
+[`Example`](https://github.com/tensorflow/tensorflow/blob/92e6c3e4f5c1cabfda1e61547a6a1b268ef95fa5/tensorflow/core/example/example.proto#L13)
+objects.
+
+### Response format
+
+A `classify` request returns a JSON object in the response body, formatted as
+follows:
+
+```json
+{
+  "result": [
+    // List of class label/score pairs for first Example (in request)
+    [ [<label1>, <score1>], [<label2>, <score2>], ... ],
+
+    // List of class label/score pairs for next Example (in request)
+    [ [<label1>, <score1>], [<label2>, <score2>], ... ],
+    ...
+  ]
+}
+```
+
+`<label>` is a string (which can be an empty string `""` if the model does not
+have a label associated with the score). `<score>` is a decimal (floating point)
+number.
+
+The `regress` request returns a JSON object in the response body, formatted as
+follows:
+
+```json
+{
+  // One regression value for each example in the request in the same order.
+  "result": [ <value1>, <value2>, <value3>, ...]
+}
+```
+
+`<value>` is a decimal number.
+
+Users of gRPC API will notice the similarity of this format with
+`ClassificationResponse` and `RegressionResponse` protos.
+
+## Predict API
+
+### Request format
+
+The request body for `predict` API must be JSON object formatted as follows:
+
+```json
+{
+  // Optional: serving signature to use.
+  // If unspecifed default serving signature is used.
+  "signature_name": <string>,
+
+  // List of tensors (each element must be of same shape and type)
+  "instances": [ <value>|<(nested)list>|<object>, ... ]
+}
+```
+
+This format is similar to `PredictRequest` proto of gRPC API and the [CMLE
+predict API](https://cloud.google.com/ml-engine/docs/v1/predict-request).
+
+When there is only one named input, the list items are expected to be scalars
+(number/string):
+
+```json
+{
+  "instances": [ "foo", "bar", "baz" ]
+}
+```
+
+or lists of these primitive types.
+
+```json
+{
+  // List of 2 tensors each of [1, 2] shape
+  "instances": [ [[1, 2]], [[3, 4]] ]
+}
+```
+
+Tensors are expressed naturally in nested notation since there is no need to
+manually flatten the list.
+
+For multiple named inputs, each item is expected to be an object containing
+input name/tensor value pair, one for each named input. As an example, the
+following is a request with two instances, each with a set of three named input
+tensors:
+
+```json
+{
+ "instances": [
+   {
+     "tag": ["foo"]
+     "signal": [1, 2, 3, 4, 5]
+     "sensor": [[1, 2], [3, 4]]
+   },
+   {
+     "tag": ["bar"]
+     "signal": [3, 4, 1, 2, 5]]
+     "sensor": [[4, 5], [6, 8]]
+   },
+ ]
+}
+```
+
+See the [Encoding binary values](#encoding-binary-values) section below for
+details on how to represent a binary (stream of bytes) value.
+
+### Response format
+
+The `predict` request returns a JSON object in response body, formatted as
+follows:
+
+```json
+{
+  "predictions": [ <value>|<(nested)list>|<object>, ...]
+}
+```
+
+If the output of the model contains only one named tensor, we omit the name and
+`predictions` key maps to a list of scalar or list values. If the model outputs
+multiple named tensors, we output a list of objects instead, similar to the
+request format mentioned above.
+
+Named tensors that have `_bytes` as a suffix in their name are considered to
+have binary values. Such values are encoded differently as described in the
+[encoding binary values](#encoding-binary-values) section below.
+
+## JSON mapping
+
+The RESTful APIs support a canonical encoding in JSON, making it easier to share
+data between systems. For supported types, the encodings are described on a
+type-by-type basis in the table below. Types not listed below are implied to be
+unsupported.
+
+[TF Data Type](https://www.tensorflow.org/versions/r1.1/programmers_guide/dims_types#data_types) | [JSON Value](http://json.org/) | JSON example                       | Notes
+------------------------------------------------------------------------------------------------ | ------------------------------ | ---------------------------------- | -----
+DT_BOOL                                                                                          | true, false                    | *true, false*                      |
+DT_STRING                                                                                        | string                         | *"Hello World!"*                   |
+DT_INT8, DT_UINT8, DT_INT16, DT_INT32, DT_UINT32, DT_INT64, DT_UINT64                            | number                         | *1, -10, 0*                        | JSON value will be a decimal number.
+DT_FLOAT, DT_DOUBLE                                                                              | number                         | *1.1, -10.0, 0, `NaN`, `Infinity`* | JSON value will be a number or one of the special token values - `NaN`, `Infinity`, and `-Infinity`. See [JSON conformance](#json-conformance) for more info. Exponent notation is also accepted.
+
+## Encoding binary values
+
+JSON uses UTF-8 encoding. If you have input feature or tensor values that need
+to be binary (like image bytes), you *must* Base64 encode the data and
+encapsulate it in a JSON object having `b64` as the key as follows:
+
+```json
+{ "b64": <base64 encoded string> }
+```
+
+You can specify this object as a value for an input feature or tensor. The same
+format is used to encode output response as well.
+
+A classification request with `image` (binary data) and `caption` features is
+shown below:
+
+```json
+{
+  "signature_name": "classify_objects",
+  "examples": [
+    {
+      "image": { "b64": "aW1hZ2UgYnl0ZXM=" },
+      "caption": "seaside"
+    },
+    {
+      "image": { "b64": "YXdlc29tZSBpbWFnZSBieXRlcw==" },
+      "caption": "mountains"
+    }
+  }
+}
+```
+
+## JSON conformance
+
+Many feature or tensor values are floating point numbers. Apart from finite
+values (e.g. 3.14, 1.0 etc.) these can have `NaN` and non-finite (`Infinity` and
+`-Infinity`) values. Unfortunately the JSON specification ([RFC
+7159](https://tools.ietf.org/html/rfc7159)) does **NOT** recognize these values
+(though the JavaScript specification does).
+
+The REST API described on this page allows request/response JSON objects to have
+such values. This implies that requests like the following one are valid:
+
+```json
+{
+  "example": [
+    {
+      "sensor_readings": [ 1.0, -3.14, Nan, Infinity ]
+    }
+  ]
+}
+```
+
+A (strict) standards compliant JSON parser will reject this with a parse error
+(due to `NaN` and `Inifinity` tokens mixed with actual numbers). To correctly
+handle requests/responses in your code, use a JSON parser that supports these
+tokens.
+
+`NaN`, `Infinity`, `-Infinity` tokens are recognized by
+[proto3](https://developers.google.com/protocol-buffers/docs/proto3#json),
+Python [JSON](https://docs.python.org/3/library/json.html) module and JavaScript
+language.
diff --git a/tensorflow_serving/model_servers/BUILD b/tensorflow_serving/model_servers/BUILD
index 92a29e70319..2d118e96a41 100644
--- a/tensorflow_serving/model_servers/BUILD
+++ b/tensorflow_serving/model_servers/BUILD
@@ -150,6 +150,33 @@ cc_test(
     ],
 )
 
+cc_test(
+    name = "http_rest_prediction_handler_test",
+    size = "medium",
+    srcs = ["http_rest_prediction_handler_test.cc"],
+    data = ["@org_tensorflow//tensorflow/cc/saved_model:saved_model_half_plus_two"],
+    deps = [
+        ":http_rest_prediction_handler",
+        ":model_platform_types",
+        ":platform_config_util",
+        ":server_core",
+        "//tensorflow_serving/core:availability_preserving_policy",
+        "//tensorflow_serving/core/test_util:test_main",
+        "//tensorflow_serving/servables/tensorflow:saved_model_bundle_source_adapter_proto",
+        "//tensorflow_serving/servables/tensorflow:session_bundle_config_proto",
+        "//tensorflow_serving/servables/tensorflow:session_bundle_source_adapter_proto",
+        "//tensorflow_serving/test_util",
+        "@com_github_tencent_rapidjson//:rapidjson",
+        "@com_google_absl//absl/strings",
+        "@com_google_absl//absl/time",
+        "@com_googlesource_code_re2//:re2",
+        "@org_tensorflow//tensorflow/cc/saved_model:loader",
+        "@org_tensorflow//tensorflow/cc/saved_model:signature_constants",
+        "@org_tensorflow//tensorflow/core:lib",
+        "@org_tensorflow//tensorflow/core:test",
+    ],
+)
+
 cc_library(
     name = "model_service_impl",
     srcs = ["model_service_impl.cc"],
@@ -181,6 +208,49 @@ cc_library(
     ],
 )
 
+cc_library(
+    name = "http_server",
+    srcs = ["http_server.cc"],
+    hdrs = ["http_server.h"],
+    visibility = ["//tensorflow_serving:internal"],
+    deps = [
+        ":http_rest_prediction_handler",
+        ":server_core",
+        "//tensorflow_serving/util:threadpool_executor",
+        "//tensorflow_serving/util/net_http/server/public:http_server",
+        "//tensorflow_serving/util/net_http/server/public:http_server_api",
+        "@com_google_absl//absl/memory",
+        "@com_google_absl//absl/strings",
+        "@com_googlesource_code_re2//:re2",
+        "@org_tensorflow//tensorflow/core:lib",
+    ],
+)
+
+cc_library(
+    name = "http_rest_prediction_handler",
+    srcs = ["http_rest_prediction_handler.cc"],
+    hdrs = ["http_rest_prediction_handler.h"],
+    visibility = ["//visibility:public"],
+    deps = [
+        ":server_core",
+        "//tensorflow_serving/apis:model_proto",
+        "//tensorflow_serving/apis:predict_proto",
+        "//tensorflow_serving/core:servable_handle",
+        "//tensorflow_serving/servables/tensorflow:classification_service",
+        "//tensorflow_serving/servables/tensorflow:predict_impl",
+        "//tensorflow_serving/servables/tensorflow:regression_service",
+        "//tensorflow_serving/util:json_tensor",
+        "@com_google_absl//absl/strings",
+        "@com_google_absl//absl/time",
+        "@com_google_absl//absl/types:optional",
+        "@com_googlesource_code_re2//:re2",
+        "@org_tensorflow//tensorflow/cc/saved_model:loader",
+        "@org_tensorflow//tensorflow/cc/saved_model:signature_constants",
+        "@org_tensorflow//tensorflow/core:lib",
+        "@org_tensorflow//tensorflow/core:protos_all_cc",
+    ],
+)
+
 SUPPORTED_TENSORFLOW_OPS = [
     "@org_tensorflow//tensorflow/contrib:contrib_kernels",
     "@org_tensorflow//tensorflow/contrib:contrib_ops_op_lib",
@@ -204,6 +274,7 @@ cc_binary(
     ],
     visibility = ["//tensorflow_serving:internal"],
     deps = [
+        ":http_server",
         ":model_platform_types",
         ":platform_config_util",
         ":server_core",
diff --git a/tensorflow_serving/model_servers/http_rest_prediction_handler.cc b/tensorflow_serving/model_servers/http_rest_prediction_handler.cc
new file mode 100644
index 00000000000..5274627f228
--- /dev/null
+++ b/tensorflow_serving/model_servers/http_rest_prediction_handler.cc
@@ -0,0 +1,193 @@
+/* Copyright 2018 Google Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#include "tensorflow_serving/model_servers/http_rest_prediction_handler.h"
+
+#include <string>
+
+#include "absl/strings/escaping.h"
+#include "absl/strings/numbers.h"
+#include "absl/strings/str_cat.h"
+#include "absl/time/time.h"
+#include "tensorflow/cc/saved_model/loader.h"
+#include "tensorflow/cc/saved_model/signature_constants.h"
+#include "tensorflow/core/lib/core/errors.h"
+#include "tensorflow_serving/apis/model.pb.h"
+#include "tensorflow_serving/apis/predict.pb.h"
+#include "tensorflow_serving/core/servable_handle.h"
+#include "tensorflow_serving/model_servers/server_core.h"
+#include "tensorflow_serving/servables/tensorflow/classification_service.h"
+#include "tensorflow_serving/servables/tensorflow/predict_impl.h"
+#include "tensorflow_serving/servables/tensorflow/regression_service.h"
+#include "tensorflow_serving/util/json_tensor.h"
+
+namespace tensorflow {
+namespace serving {
+
+using tensorflow::serving::ServerCore;
+using tensorflow::serving::TensorflowPredictor;
+
+const char* const HttpRestPredictionHandler::kPathRegex = "(?i)/v1/.*";
+
+HttpRestPredictionHandler::HttpRestPredictionHandler(
+    const RunOptions& run_options, ServerCore* core)
+    : run_options_(run_options),
+      core_(core),
+      predictor_(new TensorflowPredictor(true /* use_saved_model */)),
+      prediction_api_regex_(
+          R"((?i)/v1/models/([^/:]+)(?:/versions/(\d+))?:(classify|regress|predict))") {
+}
+
+HttpRestPredictionHandler::~HttpRestPredictionHandler() {}
+
+namespace {
+
+void AddHeaders(std::vector<std::pair<string, string>>* headers) {
+  headers->push_back({"Content-Type", "application/json"});
+}
+
+void FillJsonErrorMsg(const string& errmsg, string* output) {
+  // Errors are represented as following JSON object:
+  // {
+  //   "error": "<CEscaped error message string>"
+  // }
+  absl::StrAppend(output, R"({ "error": ")", absl::CEscape(errmsg), R"(" })");
+}
+
+}  // namespace
+
+Status HttpRestPredictionHandler::ProcessRequest(
+    const absl::string_view http_method, const absl::string_view request_path,
+    const absl::string_view request_body,
+    std::vector<std::pair<string, string>>* headers, string* output) {
+  headers->clear();
+  output->clear();
+  AddHeaders(headers);
+  string model_name;
+  string model_version_str;
+  string method;
+  Status status = errors::InvalidArgument("Malformed request: ", http_method,
+                                          " ", request_path);
+  if (http_method == "POST" &&
+      RE2::FullMatch(string(request_path), prediction_api_regex_, &model_name,
+                     &model_version_str, &method)) {
+    absl::optional<int64> model_version;
+    if (!model_version_str.empty()) {
+      int64 version;
+      if (!absl::SimpleAtoi(model_version_str, &version)) {
+        return errors::InvalidArgument(
+            "Failed to convert version: ", model_version_str, " to numeric.");
+      }
+      model_version = version;
+    }
+    if (method == "classify") {
+      status = ProcessClassifyRequest(model_name, model_version, request_body,
+                                      output);
+    } else if (method == "regress") {
+      status = ProcessRegressRequest(model_name, model_version, request_body,
+                                     output);
+    } else if (method == "predict") {
+      status = ProcessPredictRequest(model_name, model_version, request_body,
+                                     output);
+    }
+  }
+  if (!status.ok()) {
+    FillJsonErrorMsg(status.error_message(), output);
+  }
+  return status;
+}
+
+Status HttpRestPredictionHandler::ProcessClassifyRequest(
+    const absl::string_view model_name,
+    const absl::optional<int64>& model_version,
+    const absl::string_view request_body, string* output) {
+  ClassificationRequest request;
+  request.mutable_model_spec()->set_name(string(model_name));
+  if (model_version.has_value()) {
+    request.mutable_model_spec()->mutable_version()->set_value(
+        model_version.value());
+  }
+  TF_RETURN_IF_ERROR(FillClassificationRequestFromJson(request_body, &request));
+
+  ClassificationResponse response;
+  TF_RETURN_IF_ERROR(TensorflowClassificationServiceImpl::Classify(
+      run_options_, core_, request, &response));
+  TF_RETURN_IF_ERROR(
+      MakeJsonFromClassificationResult(response.result(), output));
+  return Status::OK();
+}
+
+Status HttpRestPredictionHandler::ProcessRegressRequest(
+    const absl::string_view model_name,
+    const absl::optional<int64>& model_version,
+    const absl::string_view request_body, string* output) {
+  RegressionRequest request;
+  request.mutable_model_spec()->set_name(string(model_name));
+  if (model_version.has_value()) {
+    request.mutable_model_spec()->mutable_version()->set_value(
+        model_version.value());
+  }
+  TF_RETURN_IF_ERROR(FillRegressionRequestFromJson(request_body, &request));
+
+  RegressionResponse response;
+  TF_RETURN_IF_ERROR(TensorflowRegressionServiceImpl::Regress(
+      run_options_, core_, request, &response));
+  TF_RETURN_IF_ERROR(MakeJsonFromRegressionResult(response.result(), output));
+  return Status::OK();
+}
+
+Status HttpRestPredictionHandler::ProcessPredictRequest(
+    const absl::string_view model_name,
+    const absl::optional<int64>& model_version,
+    const absl::string_view request_body, string* output) {
+  PredictRequest request;
+  request.mutable_model_spec()->set_name(string(model_name));
+  if (model_version.has_value()) {
+    request.mutable_model_spec()->mutable_version()->set_value(
+        model_version.value());
+  }
+  TF_RETURN_IF_ERROR(FillPredictRequestFromJson(
+      request_body,
+      [this, &request](const string& sig,
+                       ::google::protobuf::Map<string, TensorInfo>* map) {
+        return this->GetInfoMap(request.model_spec(), sig, map);
+      },
+      &request));
+
+  PredictResponse response;
+  TF_RETURN_IF_ERROR(
+      predictor_->Predict(run_options_, core_, request, &response));
+  TF_RETURN_IF_ERROR(MakeJsonFromTensors(response.outputs(), output));
+  return Status::OK();
+}
+
+Status HttpRestPredictionHandler::GetInfoMap(
+    const ModelSpec& model_spec, const string& signature_name,
+    ::google::protobuf::Map<string, tensorflow::TensorInfo>* infomap) {
+  ServableHandle<SavedModelBundle> bundle;
+  TF_RETURN_IF_ERROR(core_->GetServableHandle(model_spec, &bundle));
+  const string& signame =
+      signature_name.empty() ? kDefaultServingSignatureDefKey : signature_name;
+  auto iter = bundle->meta_graph_def.signature_def().find(signame);
+  if (iter == bundle->meta_graph_def.signature_def().end()) {
+    return errors::InvalidArgument("Serving signature name: \"", signame,
+                                   "\" not found in signature def");
+  }
+  *infomap = iter->second.inputs();
+  return Status::OK();
+}
+
+}  // namespace serving
+}  // namespace tensorflow
diff --git a/tensorflow_serving/model_servers/http_rest_prediction_handler.h b/tensorflow_serving/model_servers/http_rest_prediction_handler.h
new file mode 100644
index 00000000000..d3ad10184ed
--- /dev/null
+++ b/tensorflow_serving/model_servers/http_rest_prediction_handler.h
@@ -0,0 +1,114 @@
+/* Copyright 2018 Google Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_SERVING_MODEL_SERVERS_HTTP_REST_PREDICTION_HANDLER_H_
+#define TENSORFLOW_SERVING_MODEL_SERVERS_HTTP_REST_PREDICTION_HANDLER_H_
+
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
+#include "re2/re2.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/protobuf/config.pb.h"
+#include "tensorflow/core/protobuf/meta_graph.pb.h"
+
+namespace tensorflow {
+
+class SignatureDef;
+
+namespace serving {
+
+class ServerCore;
+class TensorflowPredictor;
+class ModelSpec;
+
+// HttpRestPredictionHandler handles HTTP/REST APIs of TF serving.
+//
+// Currently supported APIs are as follows:
+//
+// o Predict
+//
+//   Paths:
+//   /v1/models/<model_name>:predict (uses 'latest' version of the model).
+//   /v1/models/<model_name>/versions/<version_number>:predict
+//
+//   Request/Response format:
+//   https://cloud.google.com/ml-engine/docs/v1/predict-request
+//
+//
+// Users of this class should typically create one instance of it at process
+// startup, register paths defined by kPathRegex with the in-process HTTP
+// server, and when a request arrives, forward the request to ProcessRequest()
+// method.
+//
+// This class is thread safe.
+class HttpRestPredictionHandler {
+ public:
+  // Returns a regex that captures all API paths handled by this handler.
+  // Typical use of this method is to register request paths with underlying
+  // HTTP server, so incoming requests can be forwarded to this handler.
+  static const char* const kPathRegex;
+
+  // API calls are configured to timeout after `run_optons.timeout_in_ms`.
+  // `core` is not owned and is expected to outlive HttpRestPredictionHandler
+  // instance.
+  HttpRestPredictionHandler(const RunOptions& run_options, ServerCore* core);
+
+  ~HttpRestPredictionHandler();
+
+  // Process a HTTP request.
+  //
+  // If `http_method` (e.g. POST) and `request_path` (e.g. /v1/models/m:predict)
+  // match one of the supported APIs, the body (JSON object) is processed and
+  // response (JSON object) is returned in `output` along with output `headers`.
+  //
+  // In case of errors, the `headers` and `output` are still relevant as they
+  // contain detailed error messages, that can be relayed back to the client.
+  Status ProcessRequest(const absl::string_view http_method,
+                        const absl::string_view request_path,
+                        const absl::string_view request_body,
+                        std::vector<std::pair<string, string>>* headers,
+                        string* output);
+
+ private:
+  Status ProcessClassifyRequest(const absl::string_view model_name,
+                                const absl::optional<int64>& model_version,
+                                const absl::string_view request_body,
+                                string* output);
+  Status ProcessRegressRequest(const absl::string_view model_name,
+                               const absl::optional<int64>& model_version,
+                               const absl::string_view request_body,
+                               string* output);
+  Status ProcessPredictRequest(const absl::string_view model_name,
+                               const absl::optional<int64>& model_version,
+                               const absl::string_view request_body,
+                               string* output);
+
+  Status GetInfoMap(const ModelSpec& model_spec, const string& signature_name,
+                    ::google::protobuf::Map<string, tensorflow::TensorInfo>* infomap);
+
+  const RunOptions run_options_;
+  ServerCore* core_;
+  std::unique_ptr<TensorflowPredictor> predictor_;
+  const RE2 prediction_api_regex_;
+};
+
+}  // namespace serving
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_SERVING_MODEL_SERVERS_HTTP_REST_PREDICTION_HANDLER_H_
diff --git a/tensorflow_serving/model_servers/http_rest_prediction_handler_test.cc b/tensorflow_serving/model_servers/http_rest_prediction_handler_test.cc
new file mode 100644
index 00000000000..d9bde80eb23
--- /dev/null
+++ b/tensorflow_serving/model_servers/http_rest_prediction_handler_test.cc
@@ -0,0 +1,378 @@
+/* Copyright 2018 Google Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#include "tensorflow_serving/model_servers/http_rest_prediction_handler.h"
+
+#include <limits>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "rapidjson/document.h"
+#include "rapidjson/error/en.h"
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+#include "absl/strings/escaping.h"
+#include "absl/strings/str_cat.h"
+#include "absl/time/clock.h"
+#include "re2/re2.h"
+#include "tensorflow/cc/saved_model/loader.h"
+#include "tensorflow/cc/saved_model/signature_constants.h"
+#include "tensorflow/core/lib/core/errors.h"
+#include "tensorflow/core/lib/core/status_test_util.h"
+#include "tensorflow_serving/core/availability_preserving_policy.h"
+#include "tensorflow_serving/model_servers/model_platform_types.h"
+#include "tensorflow_serving/model_servers/platform_config_util.h"
+#include "tensorflow_serving/model_servers/server_core.h"
+#include "tensorflow_serving/servables/tensorflow/saved_model_bundle_source_adapter.pb.h"
+#include "tensorflow_serving/servables/tensorflow/session_bundle_config.pb.h"
+#include "tensorflow_serving/servables/tensorflow/session_bundle_source_adapter.pb.h"
+#include "tensorflow_serving/test_util/test_util.h"
+
+namespace tensorflow {
+namespace serving {
+namespace {
+
+using ::testing::HasSubstr;
+using ::testing::Not;
+using ::testing::UnorderedElementsAreArray;
+
+constexpr char kTestModelBasePath[] = "cc/saved_model/testdata/half_plus_two";
+constexpr char kTestModelName[] = "saved_model_half_plus_two_2_versions";
+constexpr char kNonexistentModelName[] = "nonexistent_model";
+constexpr int kTestModelVersion1 = 123;
+
+using HeaderList = std::vector<std::pair<string, string>>;
+
+class HttpRestPredictionHandlerTest : public ::testing::Test {
+ public:
+  static void SetUpTestCase() {
+    TF_ASSERT_OK(CreateServerCore(&server_core_));
+
+    const int total = 1;  // Number of models expected to be loaded.
+    int count = 0;
+    while ((count = server_core_->ListAvailableServableIds().size()) < total) {
+      LOG(INFO) << "Available servables: " << count << " waiting for " << total;
+      absl::SleepFor(absl::Milliseconds(500));
+    }
+    for (const auto& s : server_core_->ListAvailableServableIds()) {
+      LOG(INFO) << "Available servable: " << s.DebugString();
+    }
+  }
+
+  static void TearDownTestCase() { server_core_.reset(); }
+
+ protected:
+  HttpRestPredictionHandlerTest() : handler_(RunOptions(), GetServerCore()) {}
+
+  static Status CreateServerCore(std::unique_ptr<ServerCore>* server_core) {
+    ModelServerConfig config;
+    auto* model_config = config.mutable_model_config_list()->add_config();
+    model_config->set_name(kTestModelName);
+    model_config->set_base_path(
+        test_util::TensorflowTestSrcDirPath(kTestModelBasePath));
+    auto* specific_versions =
+        model_config->mutable_model_version_policy()->mutable_specific();
+    specific_versions->add_versions(kTestModelVersion1);
+
+    model_config->set_model_platform(kTensorFlowModelPlatform);
+
+    // For ServerCore Options, we leave servable_state_monitor_creator
+    // unspecified so the default servable_state_monitor_creator will be used.
+    ServerCore::Options options;
+    options.model_server_config = config;
+
+    options.platform_config_map = CreateTensorFlowPlatformConfigMap(
+        SessionBundleConfig(), true /* use_saved_model */);
+    // Reduce the number of initial load threads to be num_load_threads to avoid
+    // timing out in tests.
+    options.num_initial_load_threads = options.num_load_threads;
+    options.aspired_version_policy =
+        std::unique_ptr<AspiredVersionPolicy>(new AvailabilityPreservingPolicy);
+    return ServerCore::Create(std::move(options), server_core);
+  }
+
+  string GetJsonErrorMsg(const string& json) {
+    rapidjson::Document doc;
+    if (doc.Parse(json.c_str()).HasParseError()) {
+      return absl::StrCat("JSON Parse error: ",
+                          rapidjson::GetParseError_En(doc.GetParseError()),
+                          " for doc: ", json);
+    }
+    if (!doc.IsObject()) {
+      return absl::StrCat("JSON does not have top-level object: ", json);
+    }
+    const auto itr = doc.FindMember("error");
+    if (itr == doc.MemberEnd() || !itr->value.IsString()) {
+      return absl::StrCat("JSON object does not have \'error\' key: ", json);
+    }
+    string escaped_errmsg;
+    escaped_errmsg.assign(itr->value.GetString(), itr->value.GetStringLength());
+    string errmsg;
+    string unescaping_error;
+    if (!absl::CUnescape(escaped_errmsg, &errmsg, &unescaping_error)) {
+      return absl::StrCat("Error unescaping JSON error message: ",
+                          unescaping_error);
+    }
+    return errmsg;
+  }
+
+  ServerCore* GetServerCore() { return server_core_.get(); }
+
+  HttpRestPredictionHandler handler_;
+
+ private:
+  static std::unique_ptr<ServerCore> server_core_;
+};
+
+std::unique_ptr<ServerCore> HttpRestPredictionHandlerTest::server_core_;
+
+Status CompareJson(const string& json1, const string& json2) {
+  rapidjson::Document doc1;
+  if (doc1.Parse(json1.c_str()).HasParseError()) {
+    return errors::InvalidArgument(
+        "JSON Parse error: ", rapidjson::GetParseError_En(doc1.GetParseError()),
+        " at offset: ", doc1.GetErrorOffset(), " JSON: ", json1);
+  }
+  rapidjson::Document doc2;
+  if (doc2.Parse(json2.c_str()).HasParseError()) {
+    return errors::InvalidArgument(
+        "JSON Parse error: ", rapidjson::GetParseError_En(doc2.GetParseError()),
+        " at offset: ", doc2.GetErrorOffset(), " JSON: ", json2);
+  }
+  if (doc1 != doc2) {
+    return errors::InvalidArgument("JSON Different. JSON1: ", json1,
+                                   "JSON2: ", json2);
+  }
+  return Status::OK();
+}
+
+TEST_F(HttpRestPredictionHandlerTest, kPathRegex) {
+  EXPECT_TRUE(RE2::FullMatch("/v1/models", handler_.kPathRegex));
+  EXPECT_FALSE(RE2::FullMatch("/statuspage", handler_.kPathRegex));
+  EXPECT_FALSE(RE2::FullMatch("/index", handler_.kPathRegex));
+}
+
+TEST_F(HttpRestPredictionHandlerTest, UnsupportedApiCalls) {
+  HeaderList headers;
+  string output;
+  Status status;
+  status = handler_.ProcessRequest("GET", "/v1/foo", "", &headers, &output);
+  EXPECT_TRUE(errors::IsInvalidArgument(status));
+  EXPECT_THAT(status.error_message(), HasSubstr("Malformed request"));
+
+  status = handler_.ProcessRequest("POST", "/v1/foo", "", &headers, &output);
+  EXPECT_TRUE(errors::IsInvalidArgument(status));
+  EXPECT_THAT(status.error_message(), HasSubstr("Malformed request"));
+
+  status = handler_.ProcessRequest("GET", "/v1/models", "", &headers, &output);
+  EXPECT_TRUE(errors::IsInvalidArgument(status));
+  EXPECT_THAT(status.error_message(), HasSubstr("Malformed request"));
+
+  status = handler_.ProcessRequest("POST", "/v1/models", "", &headers, &output);
+  EXPECT_TRUE(errors::IsInvalidArgument(status));
+  EXPECT_THAT(status.error_message(), HasSubstr("Malformed request"));
+
+  status =
+      handler_.ProcessRequest("GET", "/v1/models/foo", "", &headers, &output);
+  EXPECT_TRUE(errors::IsInvalidArgument(status));
+  EXPECT_THAT(status.error_message(), HasSubstr("Malformed request"));
+
+  status = handler_.ProcessRequest("GET", "/v1/models/foo/version/50", "",
+                                   &headers, &output);
+  EXPECT_TRUE(errors::IsInvalidArgument(status));
+  EXPECT_THAT(status.error_message(), HasSubstr("Malformed request"));
+
+  status = handler_.ProcessRequest("GET", "/v1/models/foo:predict", "",
+                                   &headers, &output);
+  EXPECT_TRUE(errors::IsInvalidArgument(status));
+  EXPECT_THAT(status.error_message(), HasSubstr("Malformed request"));
+
+  status = handler_.ProcessRequest("GET", "/v1/models/foo/version/50:predict",
+                                   "", &headers, &output);
+  EXPECT_TRUE(errors::IsInvalidArgument(status));
+  EXPECT_THAT(status.error_message(), HasSubstr("Malformed request"));
+
+  status = handler_.ProcessRequest("POST", "/v1/models/foo/version/50:regress",
+                                   "", &headers, &output);
+  EXPECT_TRUE(errors::IsInvalidArgument(status));
+  EXPECT_THAT(status.error_message(), HasSubstr("Malformed request"));
+
+  status = handler_.ProcessRequest(
+      "POST", "/v1/models/foo/versions/HELLO:regress", "", &headers, &output);
+  EXPECT_TRUE(errors::IsInvalidArgument(status));
+  EXPECT_THAT(status.error_message(), HasSubstr("Malformed request"));
+
+  status = handler_.ProcessRequest(
+      "POST",
+      absl::StrCat("/v1/models/foo/versions/",
+                   std::numeric_limits<uint64>::max(), ":regress"),
+      "", &headers, &output);
+  EXPECT_TRUE(errors::IsInvalidArgument(status));
+  EXPECT_THAT(status.error_message(), HasSubstr("Failed to convert version"));
+}
+
+TEST_F(HttpRestPredictionHandlerTest, PredictModelNameVersionErrors) {
+  HeaderList headers;
+  string output;
+  Status status;
+  // 'foo' is not a valid model name.
+  status =
+      handler_.ProcessRequest("POST", "/v1/models/foo:predict",
+                              R"({ "instances": [1] })", &headers, &output);
+  EXPECT_TRUE(errors::IsNotFound(status));
+
+  // 'foo' is not a valid model name.
+  status =
+      handler_.ProcessRequest("POST", "/v1/models/foo/versions/50:predict",
+                              R"({ "instances": [1] })", &headers, &output);
+  EXPECT_TRUE(errors::IsNotFound(status));
+
+  // Valid model name, but invalid version number (99).
+  status = handler_.ProcessRequest(
+      "POST", absl::StrCat("/v1/models/", kTestModelName, "99:predict"),
+      R"({ "instances": [1] })", &headers, &output);
+  EXPECT_TRUE(errors::IsNotFound(status));
+}
+
+TEST_F(HttpRestPredictionHandlerTest, PredictRequestErrors) {
+  HeaderList headers;
+  string output;
+  Status status;
+  const string& req_path =
+      absl::StrCat("/v1/models/", kTestModelName, ":predict");
+
+  // Empty document.
+  status = handler_.ProcessRequest("POST", req_path, "", &headers, &output);
+  EXPECT_TRUE(errors::IsInvalidArgument(status));
+  EXPECT_THAT(status.error_message(),
+              HasSubstr("JSON Parse error: The document is empty"));
+
+  // Badly formatted JSON.
+  status = handler_.ProcessRequest("POST", req_path, "instances = [1, 2]",
+                                   &headers, &output);
+  EXPECT_TRUE(errors::IsInvalidArgument(status));
+  EXPECT_THAT(status.error_message(),
+              HasSubstr("JSON Parse error: Invalid value"));
+
+  // Incorrect type.
+  status = handler_.ProcessRequest(
+      "POST", req_path, R"({ "instances": [1, 2] })", &headers, &output);
+  EXPECT_TRUE(errors::IsInvalidArgument(status));
+  EXPECT_THAT(status.error_message(), HasSubstr("not of expected type: float"));
+}
+
+TEST_F(HttpRestPredictionHandlerTest, Predict) {
+  HeaderList headers;
+  string output;
+  Status status;
+  // Query latest version.
+  TF_EXPECT_OK(handler_.ProcessRequest(
+      "POST", absl::StrCat("/v1/models/", kTestModelName, ":predict"),
+      R"({"instances": [[1.0, 2.0], [3.0, 4.0]]})", &headers, &output));
+  TF_EXPECT_OK(
+      CompareJson(output, R"({ "predictions": [[2.5, 3.0], [3.5, 4.0]] })"));
+  EXPECT_THAT(headers, UnorderedElementsAreArray(
+                           (HeaderList){{"Content-Type", "application/json"}}));
+
+  // Query specific versions.
+  TF_EXPECT_OK(handler_.ProcessRequest(
+      "POST",
+      absl::StrCat("/v1/models/", kTestModelName, "/versions/",
+                   kTestModelVersion1, ":predict"),
+      R"({"instances": [1.0, 2.0]})", &headers, &output));
+  TF_EXPECT_OK(CompareJson(output, R"({ "predictions": [2.5, 3.0] })"));
+  EXPECT_THAT(headers, UnorderedElementsAreArray(
+                           (HeaderList){{"Content-Type", "application/json"}}));
+
+  // Query specific versions with explicit signature_name.
+  TF_EXPECT_OK(handler_.ProcessRequest(
+      "POST",
+      absl::StrCat("/v1/models/", kTestModelName, "/versions/",
+                   kTestModelVersion1, ":predict"),
+      R"({
+          "signature_name": "serving_default",
+          "instances": [3.0, 4.0]})",
+      &headers, &output));
+  TF_EXPECT_OK(CompareJson(output, R"({ "predictions": [3.5, 4.0] })"));
+  EXPECT_THAT(headers, UnorderedElementsAreArray(
+                           (HeaderList){{"Content-Type", "application/json"}}));
+}
+
+TEST_F(HttpRestPredictionHandlerTest, Regress) {
+  HeaderList headers;
+  string output;
+  Status status;
+  // Query latest version.
+  TF_EXPECT_OK(handler_.ProcessRequest(
+      "POST", absl::StrCat("/v1/models/", kTestModelName, ":regress"),
+      R"({
+        "signature_name": "regress_x_to_y",
+        "examples": [ { "x": 80.0 } ]
+        })",
+      &headers, &output));
+  TF_EXPECT_OK(CompareJson(output, R"({ "results": [42] })"));
+  EXPECT_THAT(headers, UnorderedElementsAreArray(
+                           (HeaderList){{"Content-Type", "application/json"}}));
+
+  // Query specific versions.
+  TF_EXPECT_OK(handler_.ProcessRequest(
+      "POST",
+      absl::StrCat("/v1/models/", kTestModelName, "/versions/",
+                   kTestModelVersion1, ":regress"),
+      R"({
+        "signature_name": "regress_x_to_y",
+        "examples": [ { "x": 80.0 } ]
+        })",
+      &headers, &output));
+  TF_EXPECT_OK(CompareJson(output, R"({ "results": [42] })"));
+  EXPECT_THAT(headers, UnorderedElementsAreArray(
+                           (HeaderList){{"Content-Type", "application/json"}}));
+}
+
+TEST_F(HttpRestPredictionHandlerTest, Classify) {
+  HeaderList headers;
+  string output;
+  Status status;
+  // Query latest version.
+  TF_EXPECT_OK(handler_.ProcessRequest(
+      "POST", absl::StrCat("/v1/models/", kTestModelName, ":classify"),
+      R"({
+        "signature_name": "classify_x_to_y",
+        "examples": [ { "x": 20.0 } ]
+        })",
+      &headers, &output));
+  TF_EXPECT_OK(CompareJson(output, R"({ "results": [[["", 12]]] })"));
+  EXPECT_THAT(headers, UnorderedElementsAreArray(
+                           (HeaderList){{"Content-Type", "application/json"}}));
+
+  // Query specific versions.
+  TF_EXPECT_OK(handler_.ProcessRequest(
+      "POST",
+      absl::StrCat("/v1/models/", kTestModelName, "/versions/",
+                   kTestModelVersion1, ":classify"),
+      R"({
+        "signature_name": "classify_x_to_y",
+        "examples": [ { "x": 10.0 } ]
+        })",
+      &headers, &output));
+  TF_EXPECT_OK(CompareJson(output, R"({ "results": [[["", 7]]] })"));
+  EXPECT_THAT(headers, UnorderedElementsAreArray(
+                           (HeaderList){{"Content-Type", "application/json"}}));
+}
+
+}  // namespace
+}  // namespace serving
+}  // namespace tensorflow
diff --git a/tensorflow_serving/model_servers/http_server.cc b/tensorflow_serving/model_servers/http_server.cc
new file mode 100644
index 00000000000..0dfaa8b32d2
--- /dev/null
+++ b/tensorflow_serving/model_servers/http_server.cc
@@ -0,0 +1,175 @@
+/* Copyright 2018 Google Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#include <cstdint>
+
+#include "absl/strings/str_cat.h"
+#include "absl/strings/string_view.h"
+#include "re2/re2.h"
+#include "tensorflow/core/platform/env.h"
+#include "tensorflow/core/platform/logging.h"
+#include "tensorflow_serving/model_servers/http_rest_prediction_handler.h"
+#include "tensorflow_serving/model_servers/http_server.h"
+#include "tensorflow_serving/model_servers/server_core.h"
+#include "tensorflow_serving/util/net_http/server/public/httpserver.h"
+#include "tensorflow_serving/util/net_http/server/public/response_code_enum.h"
+#include "tensorflow_serving/util/net_http/server/public/serverrequestinterface.h"
+#include "tensorflow_serving/util/threadpool_executor.h"
+
+namespace tensorflow {
+namespace serving {
+
+namespace {
+
+net_http::HTTPStatusCode ToHTTPStatusCode(const Status& status) {
+  using error::Code;
+  using net_http::HTTPStatusCode;
+  switch (status.code()) {
+    case Code::OK:
+      return HTTPStatusCode::OK;
+    case Code::CANCELLED:
+      return HTTPStatusCode::CLIENT_CLOSED_REQUEST;
+    case Code::UNKNOWN:
+      return HTTPStatusCode::ERROR;
+    case Code::INVALID_ARGUMENT:
+      return HTTPStatusCode::BAD_REQUEST;
+    case Code::DEADLINE_EXCEEDED:
+      return HTTPStatusCode::GATEWAY_TO;
+    case Code::NOT_FOUND:
+      return HTTPStatusCode::NOT_FOUND;
+    case Code::ALREADY_EXISTS:
+      return HTTPStatusCode::CONFLICT;
+    case Code::PERMISSION_DENIED:
+      return HTTPStatusCode::FORBIDDEN;
+    case Code::RESOURCE_EXHAUSTED:
+      return HTTPStatusCode::TOO_MANY_REQUESTS;
+    case Code::FAILED_PRECONDITION:
+      return HTTPStatusCode::BAD_REQUEST;
+    case Code::ABORTED:
+      return HTTPStatusCode::CONFLICT;
+    case Code::OUT_OF_RANGE:
+      return HTTPStatusCode::BAD_REQUEST;
+    case Code::UNIMPLEMENTED:
+      return HTTPStatusCode::NOT_IMP;
+    case Code::INTERNAL:
+      return HTTPStatusCode::ERROR;
+    case Code::UNAVAILABLE:
+      return HTTPStatusCode::SERVICE_UNAV;
+    case Code::DATA_LOSS:
+      return HTTPStatusCode::ERROR;
+    case Code::UNAUTHENTICATED:
+      return HTTPStatusCode::UNAUTHORIZED;
+    case Code::
+        DO_NOT_USE_RESERVED_FOR_FUTURE_EXPANSION_USE_DEFAULT_IN_SWITCH_INSTEAD_:
+    case error::Code_INT_MIN_SENTINEL_DO_NOT_USE_:
+    case error::Code_INT_MAX_SENTINEL_DO_NOT_USE_:
+      return HTTPStatusCode::ERROR;
+  }
+}
+
+class RequestExecutor final : public net_http::EventExecutor {
+ public:
+  explicit RequestExecutor(int num_threads)
+      : executor_(Env::Default(), "httprestserver", num_threads) {}
+
+  void Schedule(std::function<void()> fn) override { executor_.Schedule(fn); }
+
+ private:
+  ThreadPoolExecutor executor_;
+};
+
+class RestApiRequestDispatcher {
+ public:
+  RestApiRequestDispatcher(int timeout_in_ms, ServerCore* core)
+      : regex_(HttpRestPredictionHandler::kPathRegex) {
+    RunOptions run_options = RunOptions();
+    run_options.set_timeout_in_ms(timeout_in_ms);
+    handler_.reset(new HttpRestPredictionHandler(run_options, core));
+  }
+
+  net_http::RequestHandler Dispatch(net_http::ServerRequestInterface* req) {
+    if (RE2::FullMatch(string(req->uri_path()), regex_)) {
+      return [this](net_http::ServerRequestInterface* req) {
+        this->ProcessRequest(req);
+      };
+    }
+    VLOG(1) << "Ignoring HTTP request: " << req->http_method() << " "
+            << req->uri_path();
+    return nullptr;
+  }
+
+ private:
+  void ProcessRequest(net_http::ServerRequestInterface* req) {
+    string body;
+    int64_t num_bytes = 0;
+    auto request_chunk = req->ReadRequestBytes(&num_bytes);
+    while (request_chunk != nullptr) {
+      absl::StrAppend(&body, absl::string_view(request_chunk.get(), num_bytes));
+      request_chunk = req->ReadRequestBytes(&num_bytes);
+    }
+
+    std::vector<std::pair<string, string>> headers;
+    string output;
+    VLOG(1) << "Processing HTTP request: " << req->http_method() << " "
+            << req->uri_path() << " body: " << body.size() << " bytes.";
+    const auto status = handler_->ProcessRequest(
+        req->http_method(), req->uri_path(), body, &headers, &output);
+    const auto http_status = ToHTTPStatusCode(status);
+    // Note: we add headers+output for non successful status too, in case the
+    // output contains details about the error (e.g. error messages).
+    for (const auto& kv : headers) {
+      req->OverwriteResponseHeader(kv.first, kv.second);
+    }
+    req->WriteResponseString(output);
+    if (http_status != net_http::HTTPStatusCode::OK) {
+      VLOG(1) << "Error Processing HTTP/REST request: " << req->http_method()
+              << " " << req->uri_path() << " Error: " << status.ToString();
+    }
+    req->ReplyWithStatus(http_status);
+  }
+
+  const RE2 regex_;
+  std::unique_ptr<HttpRestPredictionHandler> handler_;
+};
+
+}  // namespace
+
+std::unique_ptr<net_http::HTTPServerInterface> CreateAndStartHttpServer(
+    int port, int num_threads, int timeout_in_ms, ServerCore* core) {
+  auto options = absl::make_unique<net_http::ServerOptions>();
+  options->AddPort(static_cast<uint32_t>(port));
+  options->SetExecutor(absl::make_unique<RequestExecutor>(num_threads));
+
+  auto server = net_http::CreateEvHTTPServer(std::move(options));
+  if (server == nullptr) {
+    return nullptr;
+  }
+
+  std::shared_ptr<RestApiRequestDispatcher> dispatcher =
+      std::make_shared<RestApiRequestDispatcher>(timeout_in_ms, core);
+  net_http::RequestHandlerOptions handler_options;
+  server->RegisterRequestDispatcher(
+      [dispatcher](net_http::ServerRequestInterface* req) {
+        return dispatcher->Dispatch(req);
+      },
+      handler_options);
+  if (server->StartAcceptingRequests()) {
+    return server;
+  }
+  return nullptr;
+}
+
+}  // namespace serving
+}  // namespace tensorflow
diff --git a/tensorflow_serving/model_servers/http_server.h b/tensorflow_serving/model_servers/http_server.h
new file mode 100644
index 00000000000..daa337a76fb
--- /dev/null
+++ b/tensorflow_serving/model_servers/http_server.h
@@ -0,0 +1,37 @@
+/* Copyright 2018 Google Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_SERVING_MODEL_SERVERS_HTTP_SERVER_H_
+#define TENSORFLOW_SERVING_MODEL_SERVERS_HTTP_SERVER_H_
+
+#include <memory>
+
+#include "tensorflow_serving/util/net_http/server/public/httpserverinterface.h"
+
+namespace tensorflow {
+namespace serving {
+
+class ServerCore;
+
+// Returns a HTTP Server that has following endpoints:
+//
+//   o HTTP/REST API (under /v1/models/...)
+//
+// The returned server is in a state of accepting new requests.
+std::unique_ptr<net_http::HTTPServerInterface> CreateAndStartHttpServer(
+    int port, int num_threads, int timeout_in_ms, ServerCore* core);
+
+}  // namespace serving
+}  // namespace tensorflow
+#endif  // TENSORFLOW_SERVING_MODEL_SERVERS_HTTP_SERVER_H_
diff --git a/tensorflow_serving/model_servers/main.cc b/tensorflow_serving/model_servers/main.cc
index 7a108bc3972..6fe5420a58f 100644
--- a/tensorflow_serving/model_servers/main.cc
+++ b/tensorflow_serving/model_servers/main.cc
@@ -71,6 +71,7 @@ limitations under the License.
 #include "tensorflow_serving/config/model_server_config.pb.h"
 #include "tensorflow_serving/core/availability_preserving_policy.h"
 #include "tensorflow_serving/model_servers/grpc_status_util.h"
+#include "tensorflow_serving/model_servers/http_server.h"
 #include "tensorflow_serving/model_servers/model_platform_types.h"
 #include "tensorflow_serving/model_servers/model_service_impl.h"
 #include "tensorflow_serving/model_servers/platform_config_util.h"
@@ -286,8 +287,15 @@ std::vector<GrpcChannelArgument> parseGrpcChannelArgs(
   return result;
 }
 
+struct HttpServerOptions {
+  tensorflow::int32 port;
+  tensorflow::int32 num_threads;
+  tensorflow::int32 timeout_in_ms;
+};
+
 void RunServer(int port, std::unique_ptr<ServerCore> core, bool use_saved_model,
-               const string& grpc_channel_arguments) {
+               const string& grpc_channel_arguments,
+               const HttpServerOptions& http_options) {
   // "0.0.0.0" is the way to listen on localhost in gRPC.
   const string server_address = "0.0.0.0:" + std::to_string(port);
   tensorflow::serving::ModelServiceImpl model_service(core.get());
@@ -313,6 +321,26 @@ void RunServer(int port, std::unique_ptr<ServerCore> core, bool use_saved_model,
   }
   std::unique_ptr<Server> server(builder.BuildAndStart());
   LOG(INFO) << "Running ModelServer at " << server_address << " ...";
+
+  if (http_options.port != 0) {
+    if (http_options.port != port) {
+      const string server_address =
+          "localhost:" + std::to_string(http_options.port);
+      auto http_server =
+          CreateAndStartHttpServer(http_options.port, http_options.num_threads,
+                                   http_options.timeout_in_ms, core.get());
+      if (http_server != nullptr) {
+        LOG(INFO) << "Exporting HTTP/REST API at:" << server_address << " ...";
+        http_server->WaitForTermination();
+      } else {
+        LOG(ERROR) << "Failed to start HTTP Server at " << server_address;
+      }
+    } else {
+      LOG(ERROR) << "--rest_api_port cannot be same as --port. "
+                 << "Please use a different port for HTTP/REST API. "
+                 << "Skipped exporting HTTP/REST API.";
+    }
+  }
   server->Wait();
 }
 
@@ -328,6 +356,10 @@ tensorflow::serving::PlatformConfigMap ParsePlatformConfigMap(
 
 int main(int argc, char** argv) {
   tensorflow::int32 port = 8500;
+  HttpServerOptions http_options;
+  http_options.port = 0;
+  http_options.num_threads = 4 * tensorflow::port::NumSchedulableCPUs();
+  http_options.timeout_in_ms = 30000;  // 30 seconds.
   bool enable_batching = false;
   float per_process_gpu_memory_fraction = 0;
   tensorflow::string batching_parameters_file;
@@ -344,7 +376,16 @@ int main(int argc, char** argv) {
   string model_config_file;
   string grpc_channel_arguments = "";
   std::vector<tensorflow::Flag> flag_list = {
-      tensorflow::Flag("port", &port, "port to listen on"),
+      tensorflow::Flag("port", &port, "Port to listen on for gRPC API"),
+      tensorflow::Flag("rest_api_port", &http_options.port,
+                       "Port to listen on for HTTP/REST API. If set to zero "
+                       "HTTP/REST API will not be exported. This port must be "
+                       "different than the one specified in --port."),
+      tensorflow::Flag("rest_api_num_threads", &http_options.num_threads,
+                       "Number of threads for HTTP/REST API processing. If not "
+                       "set, will be auto set based on number of CPUs."),
+      tensorflow::Flag("rest_api_timeout_in_ms", &http_options.timeout_in_ms,
+                       "Timeout for HTTP/REST API calls."),
       tensorflow::Flag("enable_batching", &enable_batching, "enable batching"),
       tensorflow::Flag("batching_parameters_file", &batching_parameters_file,
                        "If non-empty, read an ascii BatchingParameters "
@@ -470,7 +511,8 @@ int main(int argc, char** argv) {
 
   std::unique_ptr<ServerCore> core;
   TF_CHECK_OK(ServerCore::Create(std::move(options), &core));
-  RunServer(port, std::move(core), use_saved_model, grpc_channel_arguments);
+  RunServer(port, std::move(core), use_saved_model, grpc_channel_arguments,
+            http_options);
 
   return 0;
 }
diff --git a/tensorflow_serving/servables/tensorflow/BUILD b/tensorflow_serving/servables/tensorflow/BUILD
index 45f1d97ba7b..ef3e651d8ac 100644
--- a/tensorflow_serving/servables/tensorflow/BUILD
+++ b/tensorflow_serving/servables/tensorflow/BUILD
@@ -436,6 +436,9 @@ cc_library(
     name = "predict_util",
     srcs = ["predict_util.cc"],
     hdrs = ["predict_util.h"],
+    visibility = [
+        "//visibility:public",
+    ],
     deps = [
         "//tensorflow_serving/apis:predict_proto",
         "//tensorflow_serving/servables/tensorflow:util",
@@ -868,7 +871,7 @@ cc_test(
     srcs = ["util_test.cc"],
     deps = [
         ":util",
-        "//tensorflow_serving/core/test_util:test_main",  # buildcleaner: keep
+        "//tensorflow_serving/core/test_util:test_main",
         "//tensorflow_serving/test_util",
         "@org_tensorflow//tensorflow/cc/saved_model:signature_constants",
         "@org_tensorflow//tensorflow/core:framework",
diff --git a/tensorflow_serving/util/BUILD b/tensorflow_serving/util/BUILD
index f026be2d3eb..afb0e21b2a8 100644
--- a/tensorflow_serving/util/BUILD
+++ b/tensorflow_serving/util/BUILD
@@ -101,6 +101,7 @@ cc_test(
 cc_library(
     name = "fast_read_dynamic_ptr",
     hdrs = ["fast_read_dynamic_ptr.h"],
+    visibility = ["//visibility:public"],
     deps = [
         "@org_tensorflow//tensorflow/core:lib",
     ],
@@ -309,6 +310,24 @@ cc_library(
     ],
 )
 
+cc_library(
+    name = "json_tensor",
+    srcs = ["json_tensor.cc"],
+    hdrs = ["json_tensor.h"],
+    deps = [
+        "//tensorflow_serving/apis:classification_proto",
+        "//tensorflow_serving/apis:input_proto",
+        "//tensorflow_serving/apis:model_proto",
+        "//tensorflow_serving/apis:predict_proto",
+        "//tensorflow_serving/apis:regression_proto",
+        "@com_github_tencent_rapidjson//:rapidjson",
+        "@com_google_absl//absl/strings",
+        "@org_tensorflow//tensorflow/core:framework",
+        "@org_tensorflow//tensorflow/core:lib",
+        "@org_tensorflow//tensorflow/core:protos_all_cc",
+    ],
+)
+
 cc_test(
     name = "status_util_test",
     srcs = ["status_util_test.cc"],
@@ -318,6 +337,25 @@ cc_test(
     ],
 )
 
+cc_test(
+    name = "json_tensor_test",
+    srcs = ["json_tensor_test.cc"],
+    deps = [
+        ":json_tensor",
+        "//tensorflow_serving/apis:classification_proto",
+        "//tensorflow_serving/apis:model_proto",
+        "//tensorflow_serving/apis:predict_proto",
+        "//tensorflow_serving/apis:regression_proto",
+        "//tensorflow_serving/core/test_util:test_main",
+        "//tensorflow_serving/test_util",
+        "@org_tensorflow//tensorflow/core:framework",
+        "@org_tensorflow//tensorflow/core:lib",
+        "@org_tensorflow//tensorflow/core:protos_all_cc",
+        "@org_tensorflow//tensorflow/core:test",
+        "@protobuf_archive//:protobuf",
+    ],
+)
+
 load("//tensorflow_serving:serving.bzl", "serving_proto_library")
 load("//tensorflow_serving:serving.bzl", "serving_proto_library_py")
 
diff --git a/tensorflow_serving/util/json_tensor.cc b/tensorflow_serving/util/json_tensor.cc
new file mode 100644
index 00000000000..4e5b824c0b7
--- /dev/null
+++ b/tensorflow_serving/util/json_tensor.cc
@@ -0,0 +1,932 @@
+/* Copyright 2018 Google Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#include "tensorflow_serving/util/json_tensor.h"
+
+#include <limits>
+#include <string>
+#include <type_traits>
+#include <unordered_map>
+
+#include "rapidjson/document.h"
+#include "rapidjson/error/en.h"
+#include "rapidjson/prettywriter.h"
+#include "rapidjson/stringbuffer.h"
+#include "absl/strings/escaping.h"
+#include "absl/strings/match.h"
+#include "absl/strings/str_join.h"
+#include "tensorflow/core/example/example.pb.h"
+#include "tensorflow/core/example/feature.pb.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/framework/tensor_shape.pb.h"
+#include "tensorflow/core/framework/types.h"
+#include "tensorflow/core/framework/types.pb.h"
+#include "tensorflow/core/lib/core/errors.h"
+#include "tensorflow/core/lib/core/stringpiece.h"
+#include "tensorflow_serving/apis/input.pb.h"
+#include "tensorflow_serving/apis/model.pb.h"
+
+namespace tensorflow {
+namespace serving {
+namespace {
+
+// Signature name is keyed off this in the JSON request object.
+constexpr char kPredictRequestSignatureKey[] = "signature_name";
+
+// All tensors are keyed off this in the JSON request object.
+constexpr char kPredictRequestInstancesKey[] = "instances";
+
+// All examples are keyed off this in the JSON request object.
+constexpr char kClassifyRegressRequestContextKey[] = "context";
+
+// All examples are keyed off this in the JSON request object.
+constexpr char kClassifyRegressRequestExamplesKey[] = "examples";
+
+// All tensors are keyed off this in the JSON response object.
+constexpr char kPredictResponseKey[] = "predictions";
+
+// All classification/regression results are keyed off this
+// in the JSON response object.
+constexpr char kClassifyRegressResponseKey[] = "results";
+
+// All binary (base64 encoded) strings are keyd off this in JSON.
+constexpr char kBase64Key[] = "b64";
+
+// Suffix for name of tensors that represent bytes (as opposed to strings).
+constexpr char kBytesTensorNameSuffix[] = "_bytes";
+
+string JsonTypeString(const rapidjson::Value& val) {
+  switch (val.GetType()) {
+    case rapidjson::kNullType:
+      return "Null";
+    case rapidjson::kFalseType:
+      return "False";
+    case rapidjson::kTrueType:
+      return "True";
+    case rapidjson::kObjectType:
+      return "Object";
+    case rapidjson::kArrayType:
+      return "Array";
+    case rapidjson::kStringType:
+      return "String";
+    case rapidjson::kNumberType:
+      return "Number";
+  }
+}
+
+// Stringify JSON value (only for use in error reporting or debugging).
+string JsonValueToString(const rapidjson::Value& val) {
+  // TODO(b/67042542): Truncate large values.
+  rapidjson::StringBuffer buffer;
+  rapidjson::PrettyWriter<rapidjson::StringBuffer> writer(buffer);
+  val.Accept(writer);
+  return buffer.GetString();
+}
+
+// Prints a shape array in [x, y, z] format.
+string ShapeToString(const TensorShapeProto& shape) {
+  return shape.unknown_rank()
+             ? "[?]"
+             : absl::StrCat(
+                   "[",
+                   absl::StrJoin(
+                       shape.dim(), ",",
+                       [](string* out, const TensorShapeProto_Dim& dim) {
+                         out->append(absl::StrCat(dim.size()));
+                       }),
+                   "]");
+}
+
+bool IsShapeEqual(const TensorShapeProto& lhs, const TensorShapeProto& rhs) {
+  return !lhs.unknown_rank() && !rhs.unknown_rank() &&
+         lhs.dim_size() == rhs.dim_size() &&
+         std::equal(lhs.dim().begin(), lhs.dim().end(), rhs.dim().begin(),
+                    [](const TensorShapeProto_Dim& lhs,
+                       const TensorShapeProto_Dim& rhs) {
+                      return lhs.size() == rhs.size();
+                    });
+}
+
+Status TypeError(const rapidjson::Value& val, DataType dtype) {
+  return errors::InvalidArgument(
+      "JSON Value: ", JsonValueToString(val), " Type: ", JsonTypeString(val),
+      " is not of expected type: ", DataTypeString(dtype));
+}
+
+Status Base64FormatError(const rapidjson::Value& val) {
+  return errors::InvalidArgument("JSON Value: ", JsonValueToString(val),
+                                 " not formatted correctly for base64 data");
+}
+
+Status FormatError(const rapidjson::Value& val) {
+  return errors::InvalidArgument(
+      "JSON Value: ", JsonValueToString(val),
+      " not formatted correctly. Expecting object with 'instances' key and a "
+      "list/array as the value.");
+}
+
+Status FormatSignatureError(const rapidjson::Value& val) {
+  return errors::InvalidArgument(
+      "JSON Value: ", JsonValueToString(val),
+      " not formatted correctly. 'signature_name' key must be a string value.");
+}
+
+Status FloatRangeError(const rapidjson::Value& val, const string& context) {
+  return errors::InvalidArgument("JSON value: ", val.GetDouble(),
+                                 " is out of range for float. ", context,
+                                 " expects float type.");
+}
+
+bool OutOfFloatRange(const rapidjson::Value& val) {
+  // Note, JSON specification (RFC4627) does not have a way to represent
+  // non-finite (NaN, -Inf, Inf) numbers unless we loosen the parsing (which
+  // we do not presently). The isfinite() is a defensive check for the parser.
+  return std::isfinite(val.GetDouble()) &&
+         (val.GetDouble() > std::numeric_limits<float>::max() ||
+          val.GetDouble() < std::numeric_limits<float>::lowest());
+}
+
+// Adds a JSON value to Tensor. Returns error if value cannot be converted
+// to dtype. In case of error (output) tensor is not modified.
+//
+// TODO(b/67042542): Templatize on DataType
+Status AddValueToTensor(const rapidjson::Value& val, DataType dtype,
+                        TensorProto* tensor) {
+  switch (dtype) {
+    case DT_FLOAT:
+      if (!val.IsDouble()) return TypeError(val, dtype);
+      if (OutOfFloatRange(val)) return FloatRangeError(val, "Tensor");
+      tensor->add_float_val(val.GetDouble());
+      break;
+
+    case DT_DOUBLE:
+      if (!val.IsDouble()) return TypeError(val, dtype);
+      tensor->add_double_val(val.GetDouble());
+      break;
+
+    case DT_INT32:
+    case DT_INT16:
+    case DT_INT8:
+    case DT_UINT8:
+      if (!val.IsInt()) return TypeError(val, dtype);
+      tensor->add_int_val(val.GetInt());
+      break;
+
+    case DT_STRING:
+      if (!val.IsString()) return TypeError(val, dtype);
+      tensor->add_string_val(val.GetString(), val.GetStringLength());
+      break;
+
+    case DT_INT64:
+      if (!val.IsInt64()) return TypeError(val, dtype);
+      tensor->add_int64_val(val.GetInt64());
+      break;
+
+    case DT_BOOL:
+      if (!val.IsBool()) return TypeError(val, dtype);
+      tensor->add_bool_val(val.GetBool());
+      break;
+
+    case DT_UINT32:
+      if (!val.IsUint()) return TypeError(val, dtype);
+      tensor->add_uint32_val(val.GetUint());
+      break;
+
+    case DT_UINT64:
+      if (!val.IsUint64()) return TypeError(val, dtype);
+      tensor->add_uint64_val(val.GetUint64());
+      break;
+
+    default:
+      return errors::Unimplemented(
+          "Conversion of JSON Value: ", JsonValueToString(val),
+          " to type: ", DataTypeString(dtype));
+  }
+  return Status::OK();
+}
+
+// Computes and fills TensorShape corresponding to a JSON value.
+//
+// `val` can be scalar or list or list of lists with arbitrary nesting. If a
+// scalar (non array) is passed, we do not add dimension info to shape (as
+// scalars do not have a dimension).
+void GetDenseTensorShape(const rapidjson::Value& val, TensorShapeProto* shape) {
+  if (!val.IsArray()) return;
+  const auto size = val.Size();
+  shape->add_dim()->set_size(size);
+  if (size > 0) {
+    GetDenseTensorShape(val[0], shape);
+  }
+}
+
+// Returns size (number of elements) expected in a tensor of given shape.
+int GetTensorSize(const TensorShapeProto& shape) {
+  int size = 1;
+  for (const auto& dim : shape.dim()) {
+    size *= dim.size();
+  }
+  return size;
+}
+
+bool IsValBase64Object(const rapidjson::Value& val) {
+  // Base64 encoded data is a JSON object formatted as:
+  // { "b64" : "<base64 encoded string" }
+  // Note:
+  // - The object must contain only one key named as 'b64'
+  // - The key must map to a JSON string.
+  if (val.IsObject()) {
+    const auto itr = val.FindMember(kBase64Key);
+    if (itr != val.MemberEnd() && val.MemberCount() == 1 &&
+        itr->value.IsString()) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// Decodes a base64 encoded JSON string. Such strings are expected to be
+// expressed as JSON object with only one (string) key as "b64" and value of
+// this key a base64 encoded string.
+Status JsonDecodeBase64Object(const rapidjson::Value& val,
+                              string* decoded_val) {
+  if (!IsValBase64Object(val)) {
+    return Base64FormatError(val);
+  }
+  const auto itr = val.FindMember(kBase64Key);
+  if (!absl::Base64Unescape(absl::string_view(itr->value.GetString(),
+                                              itr->value.GetStringLength()),
+                            decoded_val)) {
+    return errors::InvalidArgument("Unable to base64 decode");
+  }
+  return Status::OK();
+}
+
+// Fills tensor values.
+Status FillTensorProto(const rapidjson::Value& val, int level, DataType dtype,
+                       int* val_count, TensorProto* tensor) {
+  const auto rank = tensor->tensor_shape().dim_size();
+  if (!val.IsArray()) {
+    // DOM tree for a (dense) tensor will always have all values
+    // at same (leaf) level equal to the rank of the tensor.
+    if (level != rank) {
+      return errors::InvalidArgument(
+          "JSON Value: ", JsonValueToString(val),
+          " found at incorrect level: ", level + 1,
+          " in the JSON DOM. Expected at level: ", rank);
+    }
+    Status status;
+    if (val.IsObject()) {
+      status = (dtype == DT_STRING)
+                   ? JsonDecodeBase64Object(val, tensor->add_string_val())
+                   : TypeError(val, dtype);
+    } else {
+      status = AddValueToTensor(val, dtype, tensor);
+    }
+    if (status.ok()) (*val_count)++;
+    return status;
+  }
+
+  // If list is nested deeper than rank, stop processing.
+  if (level >= rank) {
+    return errors::InvalidArgument(
+        "Encountered list at unexpected level: ", level, " expected < ", rank);
+  }
+
+  // Ensure list is of expected size for our level.
+  if (val.Size() != tensor->tensor_shape().dim(level).size()) {
+    return errors::InvalidArgument(
+        "Encountered list at unexpected size: ", val.Size(),
+        " at level: ", level,
+        " expected size: ", tensor->tensor_shape().dim(level).size());
+  }
+
+  // All OK, recurse into elements of the list.
+  for (const auto& v : val.GetArray()) {
+    TF_RETURN_IF_ERROR(FillTensorProto(v, level + 1, dtype, val_count, tensor));
+  }
+
+  return Status::OK();
+}
+
+// Converts a JSON value to tensor and add it to tensor_map.
+//
+// 'name' is the alias/name of the tensor as it appears in signature def.
+// size/shape/tensor_map are all maps keyed by the name of the tensor and
+// get updated as part of the add operation.
+Status AddInstanceItem(const rapidjson::Value& item, const string& name,
+                       const ::google::protobuf::Map<string, TensorInfo>& tensorinfo_map,
+                       ::google::protobuf::Map<string, int>* size_map,
+                       ::google::protobuf::Map<string, TensorShapeProto>* shape_map,
+                       ::google::protobuf::Map<string, TensorProto>* tensor_map) {
+  if (!tensorinfo_map.count(name)) {
+    return errors::InvalidArgument("JSON object: does not have named input: ",
+                                   name);
+  }
+  int size = 0;
+  const auto dtype = tensorinfo_map.at(name).dtype();
+  auto* tensor = &(*tensor_map)[name];
+  tensor->mutable_tensor_shape()->Clear();
+  GetDenseTensorShape(item, tensor->mutable_tensor_shape());
+  TF_RETURN_IF_ERROR(
+      FillTensorProto(item, 0 /* level */, dtype, &size, tensor));
+  if (!size_map->count(name)) {
+    (*size_map)[name] = size;
+    (*shape_map)[name] = tensor->tensor_shape();
+  } else if ((*size_map)[name] != size) {
+    return errors::InvalidArgument("Expecting tensor size: ", (*size_map)[name],
+                                   " but got: ", size);
+  } else if (!IsShapeEqual((*shape_map)[name], tensor->tensor_shape())) {
+    return errors::InvalidArgument(
+        "Expecting shape ", ShapeToString((*shape_map)[name]),
+        " but got: ", ShapeToString(tensor->tensor_shape()));
+  }
+  return Status::OK();
+}
+
+Status ParseJson(const absl::string_view json, rapidjson::Document* doc) {
+  if (json.empty()) {
+    return errors::InvalidArgument("JSON Parse error: The document is empty");
+  }
+
+  // `json` may not be null-terminated (read from a mem buffer).
+  // Wrap it in an input stream before attempting to Parse().
+  rapidjson::MemoryStream ms(json.data(), json.size());
+  rapidjson::EncodedInputStream<rapidjson::UTF8<>, rapidjson::MemoryStream>
+      jsonstream(ms);
+  // TODO(b/67042542): Switch to using custom stack for parsing to protect
+  // against deep nested structures causing excessive recursion/SO.
+  if (doc->ParseStream<rapidjson::kParseNanAndInfFlag>(jsonstream)
+          .HasParseError()) {
+    return errors::InvalidArgument(
+        "JSON Parse error: ", rapidjson::GetParseError_En(doc->GetParseError()),
+        " at offset: ", doc->GetErrorOffset());
+  }
+
+  // We expect top level JSON to be an object.
+  // {
+  //   "signature_name" : <string>
+  //   "instances" : [ <atlest one element> ]
+  //   ...
+  // }
+  if (!doc->IsObject()) return FormatError(*doc);
+  return Status::OK();
+}
+
+template <typename RequestTypeProto>
+Status FillSignature(const rapidjson::Document& doc,
+                     RequestTypeProto* request) {
+  // Fill in (optional) signature_name.
+  auto itr = doc.FindMember(kPredictRequestSignatureKey);
+  if (itr != doc.MemberEnd()) {
+    if (!itr->value.IsString()) {
+      return FormatSignatureError(doc);
+    }
+    request->mutable_model_spec()->set_signature_name(
+        itr->value.GetString(), itr->value.GetStringLength());
+  }
+  return Status::OK();
+}
+
+}  // namespace
+
+Status FillPredictRequestFromJson(
+    const absl::string_view json,
+    const std::function<tensorflow::Status(
+        const string&, ::google::protobuf::Map<string, tensorflow::TensorInfo>*)>&
+        get_tensorinfo_map,
+    PredictRequest* request) {
+  rapidjson::Document doc;
+  TF_RETURN_IF_ERROR(ParseJson(json, &doc));
+  TF_RETURN_IF_ERROR(FillSignature(doc, request));
+
+  ::google::protobuf::Map<string, tensorflow::TensorInfo> tensorinfo_map;
+  const string& signame = request->model_spec().signature_name();
+  TF_RETURN_IF_ERROR(get_tensorinfo_map(signame, &tensorinfo_map));
+  if (tensorinfo_map.empty()) {
+    return errors::InvalidArgument("Failed to get input map for signature: ",
+                                   signame.empty() ? "DEFAULT" : signame);
+  }
+
+  // Fill in tensors from (required) "instances" key.
+  auto itr = doc.FindMember(kPredictRequestInstancesKey);
+  if (itr == doc.MemberEnd()) return FormatError(doc);
+  if (!itr->value.IsArray()) return FormatError(doc);
+  if (!itr->value.Capacity()) return FormatError(doc);
+
+  // "instances" array can either be a plain list or list of objects (for named
+  // tensors) but not a mix of both. Each object must have one key for each
+  // named tensor.
+  if (!itr->value[0].IsObject() && tensorinfo_map.size() > 1) {
+    return errors::InvalidArgument(
+        "instances is a plain list, but expecting list of objects as multiple "
+        "input tensors required as per tensorinfo_map");
+  }
+
+  auto IsElementObject = [](const rapidjson::Value& val) {
+    return val.IsObject() && !IsValBase64Object(val);
+  };
+
+  const bool elements_are_objects = IsElementObject(itr->value[0]);
+
+  std::set<string> input_names;
+  for (const auto& kv : tensorinfo_map) input_names.insert(kv.first);
+
+  // Add each element of "instances" array to tensor.
+  //
+  // Each element must yield one tensor of same shape and size. All elements get
+  // batched into one tensor with the first dimension equal to the number of
+  // elements in the instances array.
+  auto* tensor_map = request->mutable_inputs();
+  tensor_map->clear();
+  ::google::protobuf::Map<string, int> size_map;
+  ::google::protobuf::Map<string, TensorShapeProto> shape_map;
+  int tensor_count = 0;
+  for (const auto& elem : itr->value.GetArray()) {
+    if (elements_are_objects) {
+      if (!IsElementObject(elem)) {
+        return errors::InvalidArgument("Expecting object but got list at item ",
+                                       tensor_count, " of input list");
+      }
+      std::set<string> object_keys;
+      for (const auto& kv : elem.GetObject()) {
+        const string& name = kv.name.GetString();
+        object_keys.insert(name);
+        const auto status = AddInstanceItem(kv.value, name, tensorinfo_map,
+                                            &size_map, &shape_map, tensor_map);
+        if (!status.ok()) {
+          return errors::InvalidArgument(
+              "Failed to process element: ", tensor_count, " key: ", name,
+              " of 'instances' list. Error: ", status.ToString());
+        }
+      }
+      if (input_names != object_keys) {
+        return errors::InvalidArgument(
+            "Failed to process element: ", tensor_count,
+            " of 'instances' list. JSON object: ", JsonValueToString(elem),
+            " must only have keys: ", absl::StrJoin(input_names, ","));
+      }
+    } else {
+      if (IsElementObject(elem)) {
+        return errors::InvalidArgument(
+            "Expecting value/list but got object at item ", tensor_count,
+            " of input list");
+      }
+      const auto& name = tensorinfo_map.begin()->first;
+      const auto status = AddInstanceItem(elem, name, tensorinfo_map, &size_map,
+                                          &shape_map, tensor_map);
+      if (!status.ok()) {
+        return errors::InvalidArgument(
+            "Failed to process element: ", tensor_count,
+            " of 'instances' list. Error: ", status.ToString());
+      }
+    }
+    tensor_count++;
+  }
+
+  // Now that all individual tensors from "instances" array are added,
+  // fix the resulting shape of the final tensor.
+  for (auto& kv : *tensor_map) {
+    const string& name = kv.first;
+    auto* tensor = &kv.second;
+    tensor->set_dtype(tensorinfo_map.at(name).dtype());
+    const auto& shape = shape_map.at(name);
+    auto* output_shape = tensor->mutable_tensor_shape();
+    output_shape->Clear();
+    output_shape->add_dim()->set_size(tensor_count);
+    for (const auto& d : shape.dim())
+      output_shape->add_dim()->set_size(d.size());
+  }
+  return Status::OK();
+}
+
+namespace {
+
+bool IsFeatureOfKind(const Feature& feature, Feature::KindCase kind) {
+  return feature.kind_case() == Feature::KIND_NOT_SET ||
+         feature.kind_case() == kind;
+}
+
+Status IncompatibleFeatureKindError(const string& feature_name,
+                                    const Feature& feature) {
+  string kind_str;
+  switch (feature.kind_case()) {
+    case Feature::KindCase::kBytesList:
+      kind_str = "bytes";
+      break;
+    case Feature::KindCase::kFloatList:
+      kind_str = "float";
+      break;
+    case Feature::KindCase::kInt64List:
+      kind_str = "int64";
+      break;
+    case Feature::KindCase::KIND_NOT_SET:
+      kind_str = "UNKNOWN";
+      break;
+  }
+  return errors::InvalidArgument("Unexpected element type in feature: ",
+                                 feature_name, " expecting type: ", kind_str);
+}
+
+// Adds a JSON value to Feature proto. Returns error if value cannot be
+// converted to dtype. In case of error (output) tensor is not modified.
+Status AddValueToFeature(const rapidjson::Value& val,
+                         const string& feature_name, Feature* feature) {
+  switch (val.GetType()) {
+    case rapidjson::kNullType:
+      return errors::InvalidArgument(
+          "Feature: ", feature_name,
+          " has element with unexpected JSON type: ", JsonTypeString(val));
+    case rapidjson::kFalseType:
+    case rapidjson::kTrueType:
+      if (!IsFeatureOfKind(*feature, Feature::KindCase::kInt64List)) {
+        return IncompatibleFeatureKindError(feature_name, *feature);
+      }
+      feature->mutable_int64_list()->add_value(val.GetBool() ? 1 : 0);
+      break;
+    case rapidjson::kObjectType:
+      if (!IsValBase64Object(val)) {
+        return errors::InvalidArgument(
+            "Feature: ", feature_name,
+            " has element with unexpected JSON type: ", JsonTypeString(val));
+      }
+      if (!IsFeatureOfKind(*feature, Feature::KindCase::kBytesList)) {
+        return IncompatibleFeatureKindError(feature_name, *feature);
+      }
+      TF_RETURN_IF_ERROR(JsonDecodeBase64Object(
+          val, feature->mutable_bytes_list()->add_value()));
+      break;
+    case rapidjson::kArrayType:
+      return errors::InvalidArgument(
+          "Feature: ", feature_name,
+          " has element with unexpected JSON type: ", JsonTypeString(val));
+    case rapidjson::kStringType:
+      if (!IsFeatureOfKind(*feature, Feature::KindCase::kBytesList)) {
+        return IncompatibleFeatureKindError(feature_name, *feature);
+      }
+      feature->mutable_bytes_list()->add_value(val.GetString(),
+                                               val.GetStringLength());
+      break;
+    case rapidjson::kNumberType:
+      if (val.IsDouble()) {
+        if (!IsFeatureOfKind(*feature, Feature::KindCase::kFloatList)) {
+          return IncompatibleFeatureKindError(feature_name, *feature);
+        }
+        if (OutOfFloatRange(val)) {
+          return FloatRangeError(val, "Example");
+        }
+        feature->mutable_float_list()->add_value(val.GetDouble());
+      } else {
+        if (!IsFeatureOfKind(*feature, Feature::KindCase::kInt64List)) {
+          return IncompatibleFeatureKindError(feature_name, *feature);
+        }
+        if (!val.IsInt64() && val.IsUint64()) {
+          return errors::InvalidArgument(
+              "Feature: ", feature_name,
+              " has uint64 element. Only int64 is supported.");
+        }
+        feature->mutable_int64_list()->add_value(val.GetInt64());
+      }
+      break;
+  }
+  return Status::OK();
+}
+
+Status MakeExampleFromJsonObject(const rapidjson::Value& val,
+                                 Example* example) {
+  if (!val.IsObject()) {
+    return errors::InvalidArgument("Example must be JSON object but got JSON ",
+                                   JsonTypeString(val));
+  }
+  for (const auto& kv : val.GetObject()) {
+    const string& name = kv.name.GetString();
+    const auto& content = kv.value;
+    Feature feature;
+    if (content.IsArray()) {
+      for (const auto& val : content.GetArray()) {
+        TF_RETURN_IF_ERROR(AddValueToFeature(val, name, &feature));
+      }
+    } else {
+      TF_RETURN_IF_ERROR(AddValueToFeature(content, name, &feature));
+    }
+    (*example->mutable_features()->mutable_feature())[name] = feature;
+  }
+  return Status::OK();
+}
+
+template <typename RequestProto>
+Status FillClassifyRegressRequestFromJson(const absl::string_view json,
+                                          RequestProto* request) {
+  rapidjson::Document doc;
+  TF_RETURN_IF_ERROR(ParseJson(json, &doc));
+  TF_RETURN_IF_ERROR(FillSignature(doc, request));
+
+  // Fill in (optional) Example context.
+  bool has_context = false;
+  auto* const input = request->mutable_input();
+  auto itr = doc.FindMember(kClassifyRegressRequestContextKey);
+  if (itr != doc.MemberEnd()) {
+    TF_RETURN_IF_ERROR(MakeExampleFromJsonObject(
+        itr->value,
+        input->mutable_example_list_with_context()->mutable_context()));
+    has_context = true;
+  }
+
+  // Fill in list of Examples.
+  itr = doc.FindMember(kClassifyRegressRequestExamplesKey);
+  if (itr == doc.MemberEnd()) return FormatError(doc);
+  if (!itr->value.IsArray()) return FormatError(doc);
+  if (!itr->value.Capacity()) return FormatError(doc);
+  for (const auto& val : itr->value.GetArray()) {
+    TF_RETURN_IF_ERROR(MakeExampleFromJsonObject(
+        val, has_context
+                 ? input->mutable_example_list_with_context()->add_examples()
+                 : input->mutable_example_list()->add_examples()));
+  }
+
+  return Status::OK();
+}
+
+}  // namespace
+
+Status FillClassificationRequestFromJson(const absl::string_view json,
+                                         ClassificationRequest* request) {
+  return FillClassifyRegressRequestFromJson(json, request);
+}
+
+Status FillRegressionRequestFromJson(const absl::string_view json,
+                                     RegressionRequest* request) {
+  return FillClassifyRegressRequestFromJson(json, request);
+}
+
+namespace {
+
+using RapidJsonWriter = rapidjson::PrettyWriter<rapidjson::StringBuffer>;
+
+bool IsNamedTensorBytes(const string& name, const TensorProto& tensor) {
+  // TODO(b/67042542): Is DT_STRING the only way to represent bytes?
+  //
+  // TODO(b/67042542): Add additional metadata in signaturedef to not rely on
+  // the name being formed with a suffix (this is borrowed from CMLE, for
+  // consistency, but is sub-optimal and TF serving should do better.
+  return tensor.dtype() == DT_STRING &&
+         absl::EndsWith(name, kBytesTensorNameSuffix);
+}
+
+template <typename dtype>
+bool WriteDecimal(RapidJsonWriter* writer, dtype val) {
+  static_assert(
+      std::is_same<dtype, float>::value || std::is_same<dtype, double>::value,
+      "Only floating-point value types are supported.");
+  // We do not use native writer->Double() API as float -> double conversion
+  // causes noise digits to be added (due to the way floating point numbers are
+  // generally represented in binary, nothing to do with the API itself). So a
+  // float value of 0.2 can get written out as 0.2000000012322 (or some such).
+  //
+  // To get around this, we write the string representation of the float number
+  // as a raw JSON value (annotated as kNumberType, to ensure JSON does not
+  // quote the string).
+  string decimal_str;
+  if (std::isfinite(val)) {
+    decimal_str = absl::StrCat(val);
+    // Add trailing '.0' for whole numbers. StrCat() formats whole numbers
+    // without one. This can lead to lists containing mix of decimal and
+    // whole numbers -- making it difficult for consumers to pick the
+    // correct type to store these numbers (note, JSON does not have
+    // metadata to describe types. These are inferred from the tokens).
+    if (decimal_str.find('.') == string::npos) {
+      absl::StrAppend(&decimal_str, ".0");
+    }
+  } else if (std::isnan(val)) {
+    decimal_str = "NaN";
+  } else if (std::isinf(val)) {
+    decimal_str = std::signbit(val) ? "-Infinity" : "Infinity";
+  }
+  return writer->RawValue(decimal_str.c_str(), decimal_str.size(),
+                          rapidjson::kNumberType);
+}
+
+Status AddSingleValueAndAdvance(const TensorProto& tensor, bool string_as_bytes,
+                                RapidJsonWriter* writer, int* offset) {
+  bool success = false;
+  switch (tensor.dtype()) {
+    case DT_FLOAT:
+      success = WriteDecimal(writer, tensor.float_val(*offset));
+      break;
+
+    case DT_DOUBLE:
+      success = WriteDecimal(writer, tensor.double_val(*offset));
+      break;
+
+    case DT_INT32:
+    case DT_INT16:
+    case DT_INT8:
+    case DT_UINT8:
+      success = writer->Int(tensor.int_val(*offset));
+      break;
+
+    case DT_STRING: {
+      const string& str = tensor.string_val(*offset);
+      if (string_as_bytes) {
+        // Write bytes as { "b64": <base64-encoded-string> }
+        string base64;
+        absl::Base64Escape(str, &base64);
+        writer->StartObject();
+        writer->Key(kBase64Key);
+        success = writer->String(base64.c_str(), base64.size());
+        writer->EndObject();
+      } else {
+        success = writer->String(str.c_str(), str.size());
+      }
+      break;
+    }
+
+    case DT_INT64:
+      success = writer->Int64(tensor.int64_val(*offset));
+      break;
+
+    case DT_BOOL:
+      success = writer->Bool(tensor.bool_val(*offset));
+      break;
+
+    case DT_UINT32:
+      success = writer->Uint(tensor.uint32_val(*offset));
+      break;
+
+    case DT_UINT64:
+      success = writer->Uint64(tensor.uint64_val(*offset));
+      break;
+
+    default:
+      success = false;
+      break;
+  }
+  if (!success) {
+    return errors::InvalidArgument(
+        "Failed to write JSON value for tensor type: ",
+        DataTypeString(tensor.dtype()));
+  }
+  (*offset)++;
+  return Status::OK();
+}
+
+Status AddTensorValues(const TensorProto& tensor, bool string_as_bytes, int dim,
+                       RapidJsonWriter* writer, int* offset) {
+  // Scalar values dont need to be enclosed in an array.
+  // Just write the (single) value out and return.
+  if (dim > tensor.tensor_shape().dim_size() - 1) {
+    return AddSingleValueAndAdvance(tensor, string_as_bytes, writer, offset);
+  }
+  writer->StartArray();
+  if (dim == tensor.tensor_shape().dim_size() - 1) {
+    for (int i = 0; i < tensor.tensor_shape().dim(dim).size(); i++) {
+      TF_RETURN_IF_ERROR(
+          AddSingleValueAndAdvance(tensor, string_as_bytes, writer, offset));
+    }
+  } else {
+    for (int i = 0; i < tensor.tensor_shape().dim(dim).size(); i++) {
+      TF_RETURN_IF_ERROR(
+          AddTensorValues(tensor, string_as_bytes, dim + 1, writer, offset));
+    }
+  }
+  writer->EndArray();
+  return Status::OK();
+}
+
+}  // namespace
+
+Status MakeJsonFromTensors(const ::google::protobuf::Map<string, TensorProto>& tensor_map,
+                           string* json) {
+  if (tensor_map.empty()) {
+    return errors::InvalidArgument("Cannot convert empty tensor map to JSON");
+  }
+
+  // Verify if each named tensor has same first dimension. The first dimension
+  // is the batchsize and for an output to be consistent, all named tensors must
+  // be batched to the same size.
+  int batch_size = 0;
+  // Track offset into value list for each tensor (used in the next section).
+  std::unordered_map<string, int> offset_map;
+  for (const auto& kv : tensor_map) {
+    const auto& name = kv.first;
+    const auto& tensor = kv.second;
+    if (tensor.tensor_shape().dim_size() == 0) {
+      return errors::InvalidArgument("Tensor name: ", name,
+                                     " has no shape information ");
+    }
+    const int cur_batch_size = tensor.tensor_shape().dim(0).size();
+    if (cur_batch_size < 1) {
+      return errors::InvalidArgument(
+          "Tensor name: ", name, " has invalid batch size: ", cur_batch_size);
+    }
+    if (batch_size != 0 && batch_size != cur_batch_size) {
+      return errors::InvalidArgument(
+          "Tensor name: ", name,
+          " has inconsistent batch size: ", cur_batch_size,
+          " expecting: ", batch_size);
+    }
+    batch_size = cur_batch_size;
+    offset_map.insert({name, 0});
+  }
+
+  rapidjson::StringBuffer buffer;
+  rapidjson::PrettyWriter<rapidjson::StringBuffer> writer(buffer);
+  writer.StartObject();
+  writer.Key(kPredictResponseKey);
+  writer.StartArray();
+  const bool elements_are_objects = tensor_map.size() > 1;
+  for (int item = 0; item < batch_size; item++) {
+    if (elements_are_objects) writer.StartObject();
+    writer.SetFormatOptions(rapidjson::kFormatSingleLineArray);
+    for (const auto& kv : tensor_map) {
+      const auto& name = kv.first;
+      const auto& tensor = kv.second;
+      if (elements_are_objects) writer.Key(name.c_str());
+      TF_RETURN_IF_ERROR(AddTensorValues(
+          tensor, IsNamedTensorBytes(name, tensor),
+          1 /* dimension, we start from 1st as 0th is batch dimension */,
+          &writer, &offset_map.at(name)));
+    }
+    writer.SetFormatOptions(rapidjson::kFormatDefault);
+    if (elements_are_objects) writer.EndObject();
+  }
+  writer.EndArray();
+  writer.EndObject();
+  json->assign(buffer.GetString());
+  return Status::OK();
+}
+
+Status MakeJsonFromClassificationResult(const ClassificationResult& result,
+                                        string* json) {
+  if (result.classifications_size() == 0) {
+    return errors::InvalidArgument(
+        "Cannot convert empty ClassificationResults to JSON");
+  }
+
+  rapidjson::StringBuffer buffer;
+  rapidjson::PrettyWriter<rapidjson::StringBuffer> writer(buffer);
+  writer.StartObject();
+  writer.Key(kClassifyRegressResponseKey);
+  writer.StartArray();
+  for (const auto& classifications : result.classifications()) {
+    writer.SetFormatOptions(rapidjson::kFormatSingleLineArray);
+    writer.StartArray();
+    for (const auto& elem : classifications.classes()) {
+      writer.StartArray();
+      if (!writer.String(elem.label().c_str(), elem.label().size())) {
+        return errors::Internal("Failed to write class label: ", elem.label(),
+                                " to output JSON buffer");
+      }
+      if (!WriteDecimal(&writer, elem.score())) {
+        return errors::Internal("Failed to write class score : ", elem.score(),
+                                " to output JSON buffer");
+      }
+      writer.EndArray();
+    }
+    writer.EndArray();
+    writer.SetFormatOptions(rapidjson::kFormatDefault);
+  }
+  writer.EndArray();
+  writer.EndObject();
+  json->assign(buffer.GetString());
+  return Status::OK();
+}
+
+Status MakeJsonFromRegressionResult(const RegressionResult& result,
+                                    string* json) {
+  if (result.regressions_size() == 0) {
+    return errors::InvalidArgument(
+        "Cannot convert empty RegressionResults to JSON");
+  }
+
+  rapidjson::StringBuffer buffer;
+  rapidjson::PrettyWriter<rapidjson::StringBuffer> writer(buffer);
+  writer.StartObject();
+  writer.Key(kClassifyRegressResponseKey);
+  writer.SetFormatOptions(rapidjson::kFormatSingleLineArray);
+  writer.StartArray();
+  for (const auto& regression : result.regressions()) {
+    if (!WriteDecimal(&writer, regression.value())) {
+      return errors::Internal("Failed to write regression value : ",
+                              regression.value(), " to output JSON buffer");
+    }
+  }
+  writer.EndArray();
+  writer.EndObject();
+  json->assign(buffer.GetString());
+  return Status::OK();
+}
+
+}  // namespace serving
+}  // namespace tensorflow
diff --git a/tensorflow_serving/util/json_tensor.h b/tensorflow_serving/util/json_tensor.h
new file mode 100644
index 00000000000..e57ad91a7cb
--- /dev/null
+++ b/tensorflow_serving/util/json_tensor.h
@@ -0,0 +1,238 @@
+/* Copyright 2018 Google Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_SERVING_UTIL_JSON_TENSOR_H_
+#define TENSORFLOW_SERVING_UTIL_JSON_TENSOR_H_
+
+#include <functional>
+#include <string>
+
+#include "absl/strings/string_view.h"
+#include "tensorflow/core/framework/tensor.pb.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/protobuf/meta_graph.pb.h"
+#include "tensorflow_serving/apis/classification.pb.h"
+#include "tensorflow_serving/apis/predict.pb.h"
+#include "tensorflow_serving/apis/regression.pb.h"
+
+namespace tensorflow {
+namespace serving {
+
+// Fills PredictRequest proto from a JSON object.
+//
+// `json` string is parsed to create TensorProtos based on the type map returned
+// via `get_tensorinfo_map` and added to `PredictRequest.inputs`. Both maps are
+// keyed by the name/alias of the tensor as it appears in the TensorFlow graph,
+// and must contain at-least one entry. The name to <type> (e.g. DT_FLOAT etc.)
+// mapping is typically part of the graph metadata.
+//
+// Following fields of the request proto are filled in:
+//
+//   `model_spec.signature_name` (string)
+//   `inputs` (map string -> tensors)
+//
+// The JSON object is expected to be formatted as follows:
+//
+// {
+//   "signature_name": <string>
+//   "instances": [ <value>|<(nested)list>|<object>, ... ]
+// }
+//
+// The "signature_name" is *optional* (if not specified, default serving
+// signature is used). The "instances" represents list of tensors (read
+// further on the formatting of these tensors below). Any other keys in the
+// top-level JSON object are ignored.
+//
+// === Notes on formatting of "instances" in the JSON ===
+//
+// The "instances" represents a list of tensors (all of same shape+type), and
+// this function builds a stack of these tensors (represented as tensor). If the
+// list has tensors of rank-R, the output tensor is of rank R+1.
+//
+// The "instances" (key) maps to list of tensors (value). Each element of the
+// list is of same type (and nesting, in case listoflists).
+//
+// {
+//   "instances": [ <value>|<(nested)list>|<object>, ... ]
+// }
+//
+// This formatting is similar to CMLE predict API:
+// https://cloud.google.com/ml-engine/docs/v1/predict-request
+//
+// o When there is only one named input (tensorinfo_map has only one key),
+//   the list items are expected to be scalars (number/string) or lists of
+//   these primitive types.
+//
+//   {
+//     "instances": [ "foo", "bar", "baz" ]
+//   }
+//   j
+//   {
+//     "instances": [ [[1, 2]], [[3], [4]] ]
+//   }
+//
+// o For multiple named inputs (tensorinfo_map has >1 keys), each item is
+//   expected to be an object containing key(name)/value(tensor) pairs, one
+//   for each named input. Representing 2 instaces of a set of 3 named input
+//   tensors would look as follows:
+//
+//   {
+//     "instances": [
+//       {
+//         "tag": ["foo"]
+//         "signal": [1, 2, 3, 4, 5]
+//         "sensor": [[1, 2], [3, 4]]
+//       },
+//       {
+//         "tag": ["bar"]
+//         "signal": [3, 4, 1, 2, 5]]
+//         "sensor": [[4, 5], [6, 8]]
+//       },
+//     ]
+//   }
+//
+// o Default encoding of strings is UTF-8. To express binary data (like image
+//   bytes) use a JSON object '{ "b64": "<base64-encoded-data>" }' instead of
+//   a raw string. Following example shows list of 2 binary strings:
+//
+//   {
+//     "instances": [ { "b64" : "aGVsbG8=" }, { "b64": "d29ybGQ=" } ]
+//   }
+tensorflow::Status FillPredictRequestFromJson(
+    const absl::string_view json,
+    const std::function<tensorflow::Status(
+        const string&, ::google::protobuf::Map<string, tensorflow::TensorInfo>*)>&
+        get_tensorinfo_map,
+    PredictRequest* request);
+
+// Fills ClassificationRequest proto from a JSON object.
+//
+// `json` string is parsed to create `Example` protos and added to
+// `ClassificationRequest.inputs`.
+//
+// Following fields of the request proto are filled in:
+//
+//   `model_spec.signature_name` (string)
+//   `input` (list of example protos)
+//
+// The JSON object is expected to be formatted as follows:
+//
+// {
+//   "signature_name": <string>
+//
+//   "context": {
+//     // Common (example) context shared by all examples.
+//     "<feature_name3>": <value>|<list>
+//     "<feature_name4>": <value>|<list>
+//   },
+//
+//   "examples": [
+//     {
+//       // Example 1
+//       "<feature_name>": <value>|<list>
+//       "<feature_name2>": <value>|<list>
+//     },
+//     {
+//       // Example 2
+//       "<feature_name>": <value>|<list>
+//       "<feature_name2>": <value>|<list>
+//     },
+//   ]
+// }
+//
+// The "signature_name" is *optional* (if not specified, default serving
+// signature is used). "context" is also optional. "exampless" represents
+// list of examples. Any other keys in the top-level JSON object are ignored.
+tensorflow::Status FillClassificationRequestFromJson(
+    const absl::string_view json, ClassificationRequest* request);
+
+// Same as FillClassificationRequestFromJson() but fills a RegressionRequest.
+// See comments above on how Example protos are expected to be formatted.
+tensorflow::Status FillRegressionRequestFromJson(const absl::string_view json,
+                                                 RegressionRequest* request);
+
+// Make JSON object from TensorProtos.
+//
+// `tensor_map` contains a map of name/alias tensor names (as it appears in the
+// TensorFlow graph) to tensor protos. The output `json` string is JSON object
+// containing all the tensors represented by these tensor protos. The first
+// dimension in each of these tensors is assumed to be the "batch" size and it
+// is expected that all tensors have the *same* batch size -- otherwise we
+// return an error, and the contents of output `json` should not be used.
+//
+// Tensors appear as list (with "batch" size elements) keyed by "predictions"
+// in the JSON object:
+//
+// {
+//   "predictions": [ <value>|<(nested)list>|<object>, ...]
+// }
+//
+// If `tensor_map` contains only one key/named tensor, the "predictions" key
+// contains a array of <value> or <(nested)list> otherwise it is an array of
+// JSON objects. See comments for MakeTensorsFromJson() above for formatting
+// details (and unit-test of examples).
+//
+// Tensors containing binary data (e.g. image bytes) are base64 encoded in the
+// JSON object. The name/alias for these tensors MUST have "_bytes" as suffix,
+// to ensure JSON has correct (base64) encoding, otherwise the resulting JSON
+// may not represent the output correctly and/or may not be parsable.
+//
+// Note, this formatting is similar to CMLE predict API:
+// https://cloud.google.com/ml-engine/docs/v1/predict-request#response-body
+tensorflow::Status MakeJsonFromTensors(
+    const ::google::protobuf::Map<string, tensorflow::TensorProto>& tensor_map,
+    string* json);
+
+// Make JSON object from ClassificationResult proto.
+//
+// The output JSON object is formatted as follows:
+//
+// {
+//   "result": [
+//      // List of class label/score pairs for first Example (in request)
+//      [ [ <label1>, <score1> ], [ <label2>, <score2> ], ... ],
+//
+//      // List of class label/score pairs for next Example (in request)
+//      [ [ <label1>, <score1> ], [ <label2>, <score2> ], ... ],
+//      ...
+//   ]
+// }
+//
+// Note, all the results are keyed by "result" key in the JSON object, and
+// they are ordered to match the input/request ordering of Examples. <label>
+// is a string, and <score> is a float number. <label> can be missing from
+// the results of graph evaluation, and these would appear as empty strings
+// in above JSON.
+tensorflow::Status MakeJsonFromClassificationResult(
+    const ClassificationResult& result, string* json);
+
+// Make JSON object from RegressionResult proto.
+//
+// The output JSON object is formatted as follows:
+//
+// {
+//   // One regression value for each example in the request in the same order.
+//   "result": [ <value1>, <value2>, <value3>, ...]
+// }
+//
+// Note, all the results are keyed by "result" key in the JSON object.
+// <value> is a float number.
+tensorflow::Status MakeJsonFromRegressionResult(const RegressionResult& result,
+                                                string* json);
+
+}  // namespace serving
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_SERVING_UTIL_JSON_TENSOR_H_
diff --git a/tensorflow_serving/util/json_tensor_test.cc b/tensorflow_serving/util/json_tensor_test.cc
new file mode 100644
index 00000000000..68e64a56922
--- /dev/null
+++ b/tensorflow_serving/util/json_tensor_test.cc
@@ -0,0 +1,1116 @@
+/* Copyright 2018 Google Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#include "tensorflow_serving/util/json_tensor.h"
+
+#include "google/protobuf/message.h"
+#include "google/protobuf/text_format.h"
+#include "google/protobuf/util/message_differencer.h"
+#include "rapidjson/document.h"
+#include "rapidjson/error/en.h"
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+#include "absl/strings/substitute.h"
+#include "tensorflow/core/lib/core/errors.h"
+#include "tensorflow/core/lib/core/status_test_util.h"
+#include "tensorflow/core/platform/protobuf.h"
+#include "tensorflow_serving/apis/model.pb.h"
+#include "tensorflow_serving/apis/predict.pb.h"
+#include "tensorflow_serving/test_util/test_util.h"
+
+namespace tensorflow {
+namespace serving {
+namespace {
+
+using protobuf::TextFormat;
+using protobuf::util::DefaultFieldComparator;
+using protobuf::util::MessageDifferencer;
+using test_util::EqualsProto;
+using ::testing::HasSubstr;
+
+using TensorInfoMap = ::google::protobuf::Map<string, TensorInfo>;
+using TensorMap = ::google::protobuf::Map<string, TensorProto>;
+
+std::function<tensorflow::Status(const string&, TensorInfoMap*)> getmap(
+    const TensorInfoMap& map) {
+  return [&map](const string&, TensorInfoMap* m) {
+    *m = map;
+    return Status::OK();
+  };
+}
+
+TEST(JsontensorTest, SingleUnnamedTensor) {
+  TensorInfoMap infomap;
+  ASSERT_TRUE(
+      TextFormat::ParseFromString("dtype: DT_INT32", &infomap["default"]));
+
+  PredictRequest req;
+  TF_EXPECT_OK(FillPredictRequestFromJson(R"(
+    {
+      "instances": [[1,2],[3,4],[5,6]]
+    })",
+                                          getmap(infomap), &req));
+  auto tmap = req.inputs();
+  EXPECT_EQ(tmap.size(), 1);
+  EXPECT_THAT(tmap["default"], EqualsProto(R"(
+    dtype: DT_INT32
+    tensor_shape {
+      dim { size: 3 }
+      dim { size: 2 }
+    }
+    int_val: 1
+    int_val: 2
+    int_val: 3
+    int_val: 4
+    int_val: 5
+    int_val: 6
+    )"));
+}
+
+TEST(JsontensorTest, SingleUnnamedTensorWithSignature) {
+  TensorInfoMap infomap;
+  ASSERT_TRUE(
+      TextFormat::ParseFromString("dtype: DT_INT32", &infomap["default"]));
+
+  PredictRequest req;
+  TF_EXPECT_OK(FillPredictRequestFromJson(R"(
+    {
+      "signature_name": "predict_images",
+      "instances": [[1,2]]
+    })",
+                                          getmap(infomap), &req));
+  EXPECT_EQ(req.model_spec().signature_name(), "predict_images");
+  auto tmap = req.inputs();
+  EXPECT_EQ(tmap.size(), 1);
+  EXPECT_THAT(tmap["default"], EqualsProto(R"(
+    dtype: DT_INT32
+    tensor_shape {
+      dim { size: 1 }
+      dim { size: 2 }
+    }
+    int_val: 1
+    int_val: 2
+    )"));
+}
+
+TEST(JsontensorTest, TensorFromNonNullTerminatedBuffer) {
+  TensorInfoMap infomap;
+  ASSERT_TRUE(
+      TextFormat::ParseFromString("dtype: DT_INT32", &infomap["default"]));
+
+  // Note, last character is a 'X' to for non-null termination.
+  const string jsonstr = R"({"instances": [[1,2],[3,4],[5,6]]}X)";
+  PredictRequest req;
+  TF_EXPECT_OK(FillPredictRequestFromJson(
+      // Process over a buffer that is not null terminated.
+      absl::string_view(jsonstr.data(), jsonstr.length() - 1), getmap(infomap),
+      &req));
+  auto tmap = req.inputs();
+  EXPECT_EQ(tmap.size(), 1);
+  EXPECT_THAT(tmap["default"], EqualsProto(R"(
+    dtype: DT_INT32
+    tensor_shape {
+      dim { size: 3 }
+      dim { size: 2 }
+    }
+    int_val: 1
+    int_val: 2
+    int_val: 3
+    int_val: 4
+    int_val: 5
+    int_val: 6
+    )"));
+}
+
+TEST(JsontensorTest, SingleUnnamedTensorBase64Scalars) {
+  TensorInfoMap infomap;
+  ASSERT_TRUE(
+      TextFormat::ParseFromString("dtype: DT_STRING", &infomap["default"]));
+
+  PredictRequest req;
+  TF_EXPECT_OK(FillPredictRequestFromJson(R"(
+    {
+      "instances": [ { "b64" : "aGVsbG8=" }, { "b64": "d29ybGQ=" } ]
+    })",
+                                          getmap(infomap), &req));
+  auto tmap = req.inputs();
+  EXPECT_EQ(tmap.size(), 1);
+  EXPECT_THAT(tmap["default"], EqualsProto(R"(
+    dtype: DT_STRING
+    tensor_shape {
+      dim { size: 2 }
+    }
+    string_val: "hello"
+    string_val: "world"
+    )"));
+}
+
+TEST(JsontensorTest, SingleUnnamedTensorBase64Lists) {
+  TensorInfoMap infomap;
+  ASSERT_TRUE(
+      TextFormat::ParseFromString("dtype: DT_STRING", &infomap["default"]));
+
+  PredictRequest req;
+  TF_EXPECT_OK(FillPredictRequestFromJson(R"(
+    {
+      "instances": [ [{ "b64" : "aGVsbG8=" }], [{ "b64": "d29ybGQ=" }] ]
+    })",
+                                          getmap(infomap), &req));
+  auto tmap = req.inputs();
+  EXPECT_EQ(tmap.size(), 1);
+  EXPECT_THAT(tmap["default"], EqualsProto(R"(
+    dtype: DT_STRING
+    tensor_shape {
+      dim { size: 2 }
+      dim { size: 1 }
+    }
+    string_val: "hello"
+    string_val: "world"
+    )"));
+}
+
+TEST(JsontensorTest, SingleNamedTensorBase64) {
+  TensorInfoMap infomap;
+  ASSERT_TRUE(
+      TextFormat::ParseFromString("dtype: DT_STRING", &infomap["default"]));
+
+  PredictRequest req;
+  TF_EXPECT_OK(FillPredictRequestFromJson(R"(
+    {
+      "instances": [
+        {
+          "default": [ [{ "b64" : "aGVsbG8=" }], [{ "b64": "d29ybGQ=" }] ]
+        }
+      ]
+    })",
+                                          getmap(infomap), &req));
+  auto tmap = req.inputs();
+  EXPECT_EQ(tmap.size(), 1);
+  EXPECT_THAT(tmap["default"], EqualsProto(R"(
+    dtype: DT_STRING
+    tensor_shape {
+      dim { size: 1 }
+      dim { size: 2 }
+      dim { size: 1 }
+    }
+    string_val: "hello"
+    string_val: "world"
+    )"));
+}
+
+TEST(JsontensorTest, MultipleNamedTensor) {
+  TensorInfoMap infomap;
+
+  // 3 named tensors with different types.
+  ASSERT_TRUE(
+      TextFormat::ParseFromString("dtype: DT_INT32", &infomap["int_tensor"]));
+  ASSERT_TRUE(
+      TextFormat::ParseFromString("dtype: DT_STRING", &infomap["str_tensor"]));
+  ASSERT_TRUE(
+      TextFormat::ParseFromString("dtype: DT_FLOAT", &infomap["float_tensor"]));
+
+  PredictRequest req;
+  TF_EXPECT_OK(FillPredictRequestFromJson(R"(
+    {
+      "instances": [
+        {
+          "int_tensor": [[1,2],[3,4],[5,6]],
+          "str_tensor": ["foo", "bar"],
+          "float_tensor": [1.0]
+        },
+        {
+          "int_tensor": [[7,8],[9,0],[1,2]],
+          "str_tensor": ["baz", "bat"],
+          "float_tensor": [2.0]
+        }
+      ]
+    })",
+                                          getmap(infomap), &req));
+
+  auto tmap = req.inputs();
+  EXPECT_EQ(tmap.size(), 3);
+  EXPECT_THAT(tmap["int_tensor"], EqualsProto(R"(
+    dtype: DT_INT32
+    tensor_shape {
+      dim { size: 2 }
+      dim { size: 3 }
+      dim { size: 2 }
+    }
+    int_val: 1
+    int_val: 2
+    int_val: 3
+    int_val: 4
+    int_val: 5
+    int_val: 6
+    int_val: 7
+    int_val: 8
+    int_val: 9
+    int_val: 0
+    int_val: 1
+    int_val: 2
+    )"));
+  EXPECT_THAT(tmap["str_tensor"], EqualsProto(R"(
+    dtype: DT_STRING
+    tensor_shape {
+      dim { size: 2 }
+      dim { size: 2 }
+    }
+    string_val: "foo"
+    string_val: "bar"
+    string_val: "baz"
+    string_val: "bat"
+    )"));
+  EXPECT_THAT(tmap["float_tensor"], EqualsProto(R"(
+    dtype: DT_FLOAT
+    tensor_shape {
+      dim { size: 2 }
+      dim { size: 1 }
+    }
+    float_val: 1.0
+    float_val: 2.0
+    )"));
+}
+
+TEST(JsontensorTest, SingleUnnamedTensorErrors) {
+  TensorInfoMap infomap;
+  ASSERT_TRUE(
+      TextFormat::ParseFromString("dtype: DT_INT32", &infomap["default"]));
+
+  PredictRequest req;
+  Status status;
+  status = FillPredictRequestFromJson("", getmap(infomap), &req);
+  ASSERT_TRUE(errors::IsInvalidArgument(status));
+  EXPECT_THAT(status.error_message(), HasSubstr("document is empty"));
+
+  status = FillPredictRequestFromJson(R"(
+    {
+      "signature_name": 5,
+      "instances": [[1,2],[3,4],[5,6,7]]
+    })",
+                                      getmap(infomap), &req);
+  ASSERT_TRUE(errors::IsInvalidArgument(status));
+  EXPECT_THAT(status.error_message(), HasSubstr("must be a string value"));
+
+  status = FillPredictRequestFromJson(R"(
+    {
+      "instances": [[1,2],[3,4],[5,6,7]]
+    })",
+                                      getmap(infomap), &req);
+  ASSERT_TRUE(errors::IsInvalidArgument(status));
+  EXPECT_THAT(status.error_message(), HasSubstr("Expecting tensor size"));
+
+  status = FillPredictRequestFromJson(R"(
+    {
+      "instances": [[1,2],[3,4],[[5,6]]]
+    })",
+                                      getmap(infomap), &req);
+  ASSERT_TRUE(errors::IsInvalidArgument(status));
+  EXPECT_THAT(status.error_message(), HasSubstr("Expecting shape"));
+
+  status = FillPredictRequestFromJson(R"(
+    {
+      "instances": [1, [1]]
+    })",
+                                      getmap(infomap), &req);
+  ASSERT_TRUE(errors::IsInvalidArgument(status));
+  EXPECT_THAT(status.error_message(), HasSubstr("Expecting shape"));
+
+  status = FillPredictRequestFromJson(R"(
+    {
+      "instances": [[1,2],["a", "b"]]
+    })",
+                                      getmap(infomap), &req);
+  ASSERT_TRUE(errors::IsInvalidArgument(status));
+  EXPECT_THAT(status.error_message(), HasSubstr("not of expected type"));
+
+  ASSERT_TRUE(
+      TextFormat::ParseFromString("dtype: DT_FLOAT", &infomap["default"]));
+  status = FillPredictRequestFromJson(
+      absl::Substitute(R"({ "instances": [$0] })",
+                       std::numeric_limits<double>::max()),
+      getmap(infomap), &req);
+  ASSERT_TRUE(errors::IsInvalidArgument(status));
+  EXPECT_THAT(status.error_message(), HasSubstr("out of range for float"));
+}
+
+TEST(JsontensorTest, MultipleNamedTensorErrors) {
+  TensorInfoMap infomap;
+
+  // 2 named tensors with different types.
+  ASSERT_TRUE(
+      TextFormat::ParseFromString("dtype: DT_INT32", &infomap["int_tensor"]));
+  ASSERT_TRUE(
+      TextFormat::ParseFromString("dtype: DT_STRING", &infomap["str_tensor"]));
+
+  PredictRequest req;
+  Status status;
+  // Different shapes across int_tensor instances.
+  status = FillPredictRequestFromJson(R"(
+    {
+      "instances": [
+        {
+          "int_tensor": [[1,2],[3,4],[5,6]],
+          "str_tensor": ["foo", "bar"]
+        },
+        {
+          "int_tensor": [[[7,8],[9,0],[1,2]]],
+          "str_tensor": ["baz", "bat"]
+        }
+      ]
+    })",
+                                      getmap(infomap), &req);
+  ASSERT_TRUE(errors::IsInvalidArgument(status));
+  EXPECT_THAT(status.error_message(), HasSubstr("Expecting shape"));
+
+  // Different size/length across int_tensor instances.
+  req.Clear();
+  status = FillPredictRequestFromJson(R"(
+    {
+      "instances": [
+        {
+          "int_tensor": [[1,2],[3,4],[5,6],[7,8]],
+          "str_tensor": ["foo", "bar"]
+        },
+        {
+          "int_tensor": [[7,8],[9,0],[1,2]],
+          "str_tensor": ["baz", "bat"]
+        }
+      ]
+    })",
+                                      getmap(infomap), &req);
+  ASSERT_TRUE(errors::IsInvalidArgument(status));
+  EXPECT_THAT(status.error_message(), HasSubstr("Expecting tensor size"));
+
+  // Mix of object and value/list in "instances" list.
+  // First element is an object. Rest are expected to be objects too.
+  req.Clear();
+  status = FillPredictRequestFromJson(R"(
+    {
+      "instances": [
+        {
+          "int_tensor": [[1,2],[3,4],[5,6]],
+          "str_tensor": ["foo", "bar"]
+        },
+        [1, 20, 30],
+        {
+          "int_tensor": [[[7,8],[9,0],[1,2]]],
+          "str_tensor": ["baz", "bat"]
+        }
+      ]
+    })",
+                                      getmap(infomap), &req);
+  ASSERT_TRUE(errors::IsInvalidArgument(status));
+  EXPECT_THAT(status.error_message(),
+              HasSubstr("Expecting object but got list"));
+
+  // Mix of object and value/list in "instances" list.
+  // First element is a list. Rest are expected to be list too.
+  infomap.clear();
+  ASSERT_TRUE(
+      TextFormat::ParseFromString("dtype: DT_STRING", &infomap["str_tensor"]));
+  req.Clear();
+  status = FillPredictRequestFromJson(R"(
+    {
+      "instances": [
+        ["baz", "bar"],
+        {
+          "str_tensor": ["baz", "bat"]
+        }
+      ]
+    })",
+                                      getmap(infomap), &req);
+  ASSERT_TRUE(errors::IsInvalidArgument(status));
+  EXPECT_THAT(status.error_message(),
+              HasSubstr("Expecting value/list but got object"));
+}
+
+template <const unsigned int parseflags = rapidjson::kParseNanAndInfFlag>
+Status CompareJson(const string& json1, const string& json2) {
+  rapidjson::Document doc1;
+  if (doc1.Parse<parseflags>(json1.c_str()).HasParseError()) {
+    return errors::InvalidArgument(
+        "LHS JSON Parse error: ",
+        rapidjson::GetParseError_En(doc1.GetParseError()),
+        " at offset: ", doc1.GetErrorOffset(), " JSON: ", json1);
+  }
+  rapidjson::Document doc2;
+  if (doc2.Parse<parseflags>(json2.c_str()).HasParseError()) {
+    return errors::InvalidArgument(
+        "RHS JSON Parse error: ",
+        rapidjson::GetParseError_En(doc2.GetParseError()),
+        " at offset: ", doc2.GetErrorOffset(), " JSON: ", json2);
+  }
+  if (doc1 != doc2) {
+    return errors::InvalidArgument("JSON Different. JSON1: ", json1,
+                                   "JSON2: ", json2);
+  }
+  return Status::OK();
+}
+
+// Compare two JSON documents treating values (including numbers) as strings.
+//
+// Use this if you are comparing JSON with decimal numbers that can have
+// NaN or +/-Inf numbers, as comparing them numerically will not work, due
+// to the approximate nature of decimal representation.
+//
+// For most use cases, prefer CompareJson() defined above.
+Status CompareJsonAllValuesAsStrings(const string& json1, const string& json2) {
+  return CompareJson<rapidjson::kParseNanAndInfFlag |
+                     rapidjson::kParseNumbersAsStringsFlag>(json1, json2);
+}
+
+TEST(JsontensorTest, FromJsonSingleTensor) {
+  TensorMap tensormap;
+  ASSERT_TRUE(TextFormat::ParseFromString(R"(
+    dtype: DT_INT32
+    tensor_shape {
+      dim { size: 2 }
+      dim { size: 3 }
+      dim { size: 2 }
+    }
+    int_val: 1
+    int_val: 2
+    int_val: 3
+    int_val: 4
+    int_val: 5
+    int_val: 6
+    int_val: 7
+    int_val: 8
+    int_val: 9
+    int_val: 0
+    int_val: 1
+    int_val: 2
+    )",
+                                          &tensormap["int_tensor"]));
+
+  string json;
+  TF_EXPECT_OK(MakeJsonFromTensors(tensormap, &json));
+  TF_EXPECT_OK(CompareJson(json, R"({
+    "predictions": [[[1, 2], [3, 4], [5, 6]], [[7, 8], [9, 0], [1, 2]]
+    ]})"));
+}
+
+TEST(JsontensorTest, FromJsonSingleScalarTensor) {
+  TensorMap tensormap;
+  ASSERT_TRUE(TextFormat::ParseFromString(R"(
+    dtype: DT_INT32
+    tensor_shape {
+      dim { size: 5 }
+    }
+    int_val: 1
+    int_val: 2
+    int_val: 3
+    int_val: 4
+    int_val: 5
+    )",
+                                          &tensormap["int_tensor"]));
+
+  string json;
+  TF_EXPECT_OK(MakeJsonFromTensors(tensormap, &json));
+  TF_EXPECT_OK(CompareJson(json, R"({ "predictions": [1, 2, 3, 4, 5] })"));
+}
+
+TEST(JsontensorTest, FromJsonSingleBytesTensor) {
+  TensorMap tensormap;
+  ASSERT_TRUE(TextFormat::ParseFromString(R"(
+    dtype: DT_STRING
+    tensor_shape {
+      dim { size: 2 }
+      dim { size: 2 }
+    }
+    string_val: "hello"
+    string_val: "world"
+    string_val: "tf"
+    string_val: "serving"
+    )",
+                                          &tensormap["str_tensor_bytes"]));
+
+  string json;
+  TF_EXPECT_OK(MakeJsonFromTensors(tensormap, &json));
+  TF_EXPECT_OK(CompareJson(json, R"({
+    "predictions": [
+      [{"b64": "aGVsbG8="}, {"b64": "d29ybGQ="}],
+      [{"b64": "dGY="}, {"b64": "c2VydmluZw=="}]
+    ]})"));
+}
+
+TEST(JsontensorTest, FromJsonSingleFloatTensorNonFinite) {
+  TensorMap tensormap;
+  ASSERT_TRUE(TextFormat::ParseFromString(R"(
+    dtype: DT_FLOAT
+    tensor_shape {
+      dim { size: 2 }
+      dim { size: 2 }
+    }
+    float_val: NaN
+    float_val: Infinity
+    float_val: 3
+    float_val: -Infinity
+    )",
+                                          &tensormap["float_tensor"]));
+
+  string json;
+  TF_EXPECT_OK(MakeJsonFromTensors(tensormap, &json));
+  TF_EXPECT_OK(CompareJsonAllValuesAsStrings(json, R"({
+    "predictions": [
+      [NaN, Infinity],
+      [3.0, -Infinity]
+    ]})"));
+}
+
+TEST(JsontensorTest, FromJsonSingleTensorErrors) {
+  TensorMap tensormap;
+  string json;
+  Status status;
+
+  status = MakeJsonFromTensors(tensormap, &json);
+  ASSERT_TRUE(errors::IsInvalidArgument(status));
+  EXPECT_THAT(status.error_message(), HasSubstr("empty tensor map"));
+
+  ASSERT_TRUE(TextFormat::ParseFromString(R"(
+    dtype: DT_COMPLEX64
+    tensor_shape {
+      dim { size: 2 }
+    }
+    scomplex_val: 1.0
+    scomplex_val: 2.0
+    )",
+                                          &tensormap["tensor"]));
+  status = MakeJsonFromTensors(tensormap, &json);
+  ASSERT_TRUE(errors::IsInvalidArgument(status));
+  EXPECT_THAT(status.error_message(), HasSubstr("tensor type: complex64"));
+
+  ASSERT_TRUE(TextFormat::ParseFromString(R"(
+    dtype: DT_INT32
+    int_val: 1
+    )",
+                                          &tensormap["tensor"]));
+  status = MakeJsonFromTensors(tensormap, &json);
+  ASSERT_TRUE(errors::IsInvalidArgument(status));
+  EXPECT_THAT(status.error_message(), HasSubstr("no shape information"));
+}
+
+TEST(JsontensorTest, FromJsonMultipleNamedTensors) {
+  TensorMap tensormap;
+  ASSERT_TRUE(TextFormat::ParseFromString(R"(
+        dtype: DT_INT32
+        tensor_shape {
+          dim { size: 2 }
+          dim { size: 3 }
+          dim { size: 2 }
+        }
+        int_val: 1
+        int_val: 2
+        int_val: 3
+        int_val: 4
+        int_val: 5
+        int_val: 6
+        int_val: 7
+        int_val: 8
+        int_val: 9
+        int_val: 0
+        int_val: 1
+        int_val: 2
+        )",
+                                          &tensormap["int_tensor"]));
+
+  ASSERT_TRUE(TextFormat::ParseFromString(R"(
+    dtype: DT_STRING
+    tensor_shape {
+      dim { size: 2 }
+      dim { size: 2 }
+    }
+    string_val: "foo"
+    string_val: "bar"
+    string_val: "baz"
+    string_val: "bat"
+    )",
+                                          &tensormap["str_tensor"]));
+
+  ASSERT_TRUE(TextFormat::ParseFromString(R"(
+    dtype: DT_FLOAT
+    tensor_shape {
+      dim { size: 2 }
+      dim { size: 1 }
+    }
+    float_val: 1.0
+    float_val: 2.0
+    )",
+                                          &tensormap["float_tensor"]));
+
+  ASSERT_TRUE(TextFormat::ParseFromString(R"(
+    dtype: DT_DOUBLE
+    tensor_shape {
+      dim { size: 2 }
+    }
+    double_val: 8.0
+    double_val: 9.0
+    )",
+                                          &tensormap["double_scalar_tensor"]));
+
+  ASSERT_TRUE(TextFormat::ParseFromString(R"(
+    dtype: DT_STRING
+    tensor_shape {
+      dim { size: 2 }
+      dim { size: 2 }
+    }
+    string_val: "hello"
+    string_val: "world"
+    string_val: "tf"
+    string_val: "serving"
+    )",
+                                          &tensormap["str_tensor_bytes"]));
+
+  string json;
+  TF_EXPECT_OK(MakeJsonFromTensors(tensormap, &json));
+  TF_EXPECT_OK(CompareJson(json, R"({
+    "predictions": [
+        {
+            "double_scalar_tensor": 8.0,
+            "float_tensor": [1.0],
+            "int_tensor": [[1, 2], [3, 4], [5, 6]],
+            "str_tensor": ["foo", "bar"],
+            "str_tensor_bytes": [ {"b64": "aGVsbG8="}, {"b64": "d29ybGQ="} ]
+        },
+        {
+            "double_scalar_tensor": 9.0,
+            "float_tensor": [2.0],
+            "int_tensor": [[7, 8], [9, 0], [1, 2]],
+            "str_tensor": ["baz", "bat"],
+            "str_tensor_bytes": [ {"b64": "dGY="}, {"b64": "c2VydmluZw=="} ]
+        }
+    ]})"));
+}
+
+TEST(JsontensorTest, FromJsonMultipleNamedTensorsErrors) {
+  TensorMap tensormap;
+  ASSERT_TRUE(TextFormat::ParseFromString(R"(
+    dtype: DT_INT32
+    tensor_shape {
+      dim { size: 2 }
+      dim { size: 3 }
+    }
+    int_val: 1
+    int_val: 2
+    int_val: 3
+    int_val: 4
+    int_val: 5
+    int_val: 6
+    )",
+                                          &tensormap["int_tensor"]));
+
+  ASSERT_TRUE(TextFormat::ParseFromString(R"(
+    dtype: DT_STRING
+    tensor_shape {
+      dim { size: 1 }
+      dim { size: 3 }
+    }
+    string_val: "foo"
+    string_val: "bar"
+    string_val: "baz"
+    )",
+                                          &tensormap["str_tensor"]));
+
+  string json;
+  const auto& status = MakeJsonFromTensors(tensormap, &json);
+  ASSERT_TRUE(errors::IsInvalidArgument(status));
+  EXPECT_THAT(status.error_message(), HasSubstr("inconsistent batch size"));
+}
+
+template <typename RequestType>
+class ClassifyRegressRequestTest : public ::testing::Test {
+ protected:
+  Status FillRequest(const string& json, ClassificationRequest* req) {
+    return FillClassificationRequestFromJson(json, req);
+  }
+
+  Status FillRequest(const string& json, RegressionRequest* req) {
+    return FillRegressionRequestFromJson(json, req);
+  }
+};
+
+typedef ::testing::Types<ClassificationRequest, RegressionRequest> RequestTypes;
+TYPED_TEST_CASE(ClassifyRegressRequestTest, RequestTypes);
+
+TYPED_TEST(ClassifyRegressRequestTest, RequestNoContext) {
+  TypeParam req;
+  TF_EXPECT_OK(this->FillRequest(R"(
+    {
+      "examples": [
+        {
+          "names": [ "foo", "bar" ],
+          "ratings": [ 8.0, 9.0 ],
+          "age": 20
+        },
+        {
+          "names": [ "baz" ],
+          "ratings": 6.0
+        }
+      ]
+    })",
+                                 &req));
+
+  TypeParam expected_req;
+  ASSERT_TRUE(TextFormat::ParseFromString(R"(
+    input {
+      example_list {
+        examples {
+          features {
+            feature {
+              key: "names"
+              value { bytes_list {
+                value: "foo"
+                value: "bar"
+              }}
+            }
+            feature {
+              key: "ratings"
+              value { float_list {
+                value: 8.0
+                value: 9.0
+              }}
+            }
+            feature {
+              key: "age"
+              value { int64_list {
+                value: 20
+              }}
+            }
+          }
+        }
+        examples {
+          features {
+            feature {
+              key: "names"
+              value { bytes_list {
+                value: "baz"
+              }}
+            }
+            feature {
+              key: "ratings"
+              value { float_list {
+                value: 6.0
+              }}
+            }
+          }
+        }
+      }
+    }
+  )",
+                                          &expected_req));
+  EXPECT_TRUE(MessageDifferencer::ApproximatelyEquals(req, expected_req))
+      << "Expected Proto: " << expected_req.DebugString();
+}
+
+TYPED_TEST(ClassifyRegressRequestTest, RequestWithContextAndSignature) {
+  TypeParam req;
+  TF_EXPECT_OK(this->FillRequest(R"(
+    {
+      "signature_name": "custom_signture",
+      "context": {
+        "query": "pizza",
+        "location": [ "sfo" ]
+      },
+      "examples": [
+        {
+          "names": [ "foo", "bar" ],
+          "ratings": [ 8.0, 9.0, NaN, Infinity ],
+          "age": 20
+        },
+        {
+          "names": [ "baz", { "b64": "aGVsbG8=" } ],
+          "ratings": 6.0,
+          "intboolmix": [ 1, true, false ]
+        },
+        {
+          "names": "bar",
+          "ratings": -Infinity
+        }
+      ]
+    })",
+                                 &req));
+
+  TypeParam expected_req;
+  ASSERT_TRUE(TextFormat::ParseFromString(R"(
+    model_spec {
+      signature_name: "custom_signture"
+    }
+    input {
+      example_list_with_context {
+        context {
+          features {
+            feature {
+              key: "query"
+              value { bytes_list {
+                value: "pizza"
+              }}
+            }
+            feature {
+              key: "location"
+              value { bytes_list {
+                value: "sfo"
+              }}
+            }
+          }
+        }
+        examples {
+          features {
+            feature {
+              key: "names"
+              value { bytes_list {
+                value: "foo"
+                value: "bar"
+              }}
+            }
+            feature {
+              key: "ratings"
+              value { float_list {
+                value: 8.0
+                value: 9.0
+                value: NaN
+                value: Infinity
+              }}
+            }
+            feature {
+              key: "age"
+              value { int64_list {
+                value: 20
+              }}
+            }
+          }
+        }
+        examples {
+          features {
+            feature {
+              key: "names"
+              value { bytes_list {
+                value: "baz"
+                value: "hello"
+              }}
+            }
+            feature {
+              key: "ratings"
+              value { float_list {
+                value: 6.0
+              }}
+            }
+            feature {
+              key: "intboolmix"
+              value { int64_list {
+                value: 1
+                value: 1
+                value: 0
+              }}
+            }
+          }
+        }
+        examples {
+          features {
+            feature {
+              key: "names"
+              value { bytes_list {
+                value: "bar"
+              }}
+            }
+            feature {
+              key: "ratings"
+              value { float_list {
+                value: -Infinity
+              }}
+            }
+          }
+        }
+
+      }
+    }
+  )",
+                                          &expected_req));
+  DefaultFieldComparator comparator;
+  comparator.set_float_comparison(DefaultFieldComparator::APPROXIMATE);
+  comparator.set_treat_nan_as_equal(true);
+  MessageDifferencer differencer;
+  differencer.set_field_comparator(&comparator);
+  EXPECT_TRUE(differencer.Compare(req, expected_req))
+      << "Expected proto: " << expected_req.DebugString()
+      << "But got proto: " << req.DebugString();
+}
+
+TYPED_TEST(ClassifyRegressRequestTest, JsonErrors) {
+  TypeParam req;
+  auto status = this->FillRequest(R"(
+    {
+      "signature_name": [ "hello" ],
+      "examples": [ { "names": [ "foo", "bar" ] } ]
+    })",
+                                  &req);
+  ASSERT_TRUE(errors::IsInvalidArgument(status));
+  EXPECT_THAT(status.error_message(),
+              HasSubstr("'signature_name' key must be a string"));
+
+  req.Clear();
+  status = this->FillRequest(R"(
+    {
+      "context": [ { "names": [ "foo", "bar" ] } ]
+    })",
+                             &req);
+  ASSERT_TRUE(errors::IsInvalidArgument(status));
+  EXPECT_THAT(status.error_message(), HasSubstr("Example must be JSON object"));
+
+  req.Clear();
+  status = this->FillRequest(R"(
+    {
+      "examples": { "names": [ "foo", "bar" ] }
+    })",
+                             &req);
+  ASSERT_TRUE(errors::IsInvalidArgument(status));
+  EXPECT_THAT(status.error_message(), HasSubstr("list/array as the value"));
+
+  req.Clear();
+  status = this->FillRequest(R"(
+    {
+      "examples": [ [ { "names": [ "foo", "bar" ] } ] ]
+    })",
+                             &req);
+  ASSERT_TRUE(errors::IsInvalidArgument(status));
+  EXPECT_THAT(status.error_message(), HasSubstr("Example must be JSON object"));
+
+  req.Clear();
+  status = this->FillRequest(R"(
+    {
+      "examples": [ { "names": [ 10, null ] } ]
+    })",
+                             &req);
+  ASSERT_TRUE(errors::IsInvalidArgument(status));
+  EXPECT_THAT(status.error_message(),
+              HasSubstr("names has element with unexpected JSON type: Null"));
+
+  req.Clear();
+  status = this->FillRequest(R"(
+    {
+      "examples": [ { "names": [ 10, 10.0 ] } ]
+    })",
+                             &req);
+  ASSERT_TRUE(errors::IsInvalidArgument(status));
+  EXPECT_THAT(status.error_message(),
+              HasSubstr("feature: names expecting type: int64"));
+
+  req.Clear();
+  status = this->FillRequest(R"(
+    {
+      "examples": [ { "names": [ 10, { "test": 10 } ] } ]
+    })",
+                             &req);
+  ASSERT_TRUE(errors::IsInvalidArgument(status));
+  EXPECT_THAT(status.error_message(),
+              HasSubstr("names has element with unexpected JSON type: Object"));
+
+  req.Clear();
+  status = this->FillRequest(R"(
+    {
+      "examples": [ { "names": [ [10], 20 ] } ]
+    })",
+                             &req);
+  ASSERT_TRUE(errors::IsInvalidArgument(status));
+  EXPECT_THAT(status.error_message(),
+              HasSubstr("names has element with unexpected JSON type: Array"));
+
+  req.Clear();
+  status = this->FillRequest(R"(
+    {
+      "examples": [ { "names": [ 20, 18446744073709551603 ] } ]
+    })",
+                             &req);
+  ASSERT_TRUE(errors::IsInvalidArgument(status));
+  EXPECT_THAT(status.error_message(), HasSubstr("Only int64 is supported"));
+
+  req.Clear();
+  status = this->FillRequest(
+      absl::Substitute(R"({ "examples": [ { "names": $0 } ] })",
+                       std::numeric_limits<double>::max()),
+      &req);
+  ASSERT_TRUE(errors::IsInvalidArgument(status));
+  EXPECT_THAT(status.error_message(), HasSubstr("out of range for float"));
+}
+
+TEST(ClassifyRegressnResultTest, JsonFromClassificationResult) {
+  ClassificationResult result;
+  ASSERT_TRUE(TextFormat::ParseFromString(R"(
+    classifications {
+      classes { label: "car" score: 0.2 }
+      classes { label: "bike" score: 0.7 }
+      classes { label: "bus" score: 0.1 }
+    }
+    classifications {
+      classes { label: "car" score: 0.7 }
+      classes { label: "bike" score: 0.1 }
+      classes { label: "bus" score: 0.2 }
+    })",
+                                          &result));
+
+  string json;
+  TF_EXPECT_OK(MakeJsonFromClassificationResult(result, &json));
+  TF_EXPECT_OK(CompareJson(json, R"({
+    "results": [
+      [ ["car", 0.2], ["bike", 0.7], ["bus", 0.1] ],
+      [ ["car", 0.7], ["bike", 0.1], ["bus", 0.2] ]
+    ]
+  })"));
+}
+
+TEST(ClassifyRegressnResultTest, JsonFromRegressionResult) {
+  RegressionResult result;
+  ASSERT_TRUE(TextFormat::ParseFromString(R"(
+    regressions { value: 0.2 }
+    regressions { value: 0.9 }
+    regressions { value: 1.0 }
+    )",
+                                          &result));
+
+  string json;
+  TF_EXPECT_OK(MakeJsonFromRegressionResult(result, &json));
+  TF_EXPECT_OK(CompareJson(json, R"({ "results": [ 0.2, 0.9, 1.0 ] })"));
+}
+
+TEST(ClassifyRegressnResultTest, JsonFromRegressionResultWithNonFinite) {
+  RegressionResult result;
+  ASSERT_TRUE(TextFormat::ParseFromString(R"(
+    regressions { value: 0.2 }
+    regressions { value: Infinity }
+    regressions { value: 1.0 }
+    regressions { value: -Infinity }
+    regressions { value: NaN }
+    )",
+                                          &result));
+
+  string json;
+  TF_EXPECT_OK(MakeJsonFromRegressionResult(result, &json));
+  TF_EXPECT_OK(CompareJsonAllValuesAsStrings(
+      json, R"({ "results": [ 0.2, Infinity, 1.0, -Infinity, NaN ] })"));
+}
+
+TEST(ClassifyRegressnResultTest, JsonFromResultErrors) {
+  string json;
+  auto status = MakeJsonFromClassificationResult(ClassificationResult(), &json);
+  ASSERT_TRUE(errors::IsInvalidArgument(status));
+  EXPECT_THAT(status.error_message(), HasSubstr("empty ClassificationResults"));
+
+  status = MakeJsonFromRegressionResult(RegressionResult(), &json);
+  ASSERT_TRUE(errors::IsInvalidArgument(status));
+  EXPECT_THAT(status.error_message(), HasSubstr("empty RegressionResults"));
+}
+
+}  // namespace
+}  // namespace serving
+}  // namespace tensorflow
diff --git a/tensorflow_serving/util/net_http/OWNERS b/tensorflow_serving/util/net_http/OWNERS
new file mode 100644
index 00000000000..bb25f9c2c39
--- /dev/null
+++ b/tensorflow_serving/util/net_http/OWNERS
@@ -0,0 +1,2 @@
+awk
+wenboz
\ No newline at end of file
diff --git a/tensorflow_serving/util/net_http/README.md b/tensorflow_serving/util/net_http/README.md
new file mode 100644
index 00000000000..73de2f8f0a4
--- /dev/null
+++ b/tensorflow_serving/util/net_http/README.md
@@ -0,0 +1,11 @@
+A (truly) lightweight OSS HTTP Server
+=====================================
+
+Design and implementation started in April 2018, within the TF serving code base.
+
+APIs are subject to change.
+
+Questions?
+----------
+
+If you have any questions, please send them to [web|awk]@google.com
diff --git a/tensorflow_serving/util/net_http/client/BUILD b/tensorflow_serving/util/net_http/client/BUILD
new file mode 100644
index 00000000000..e64c94c680c
--- /dev/null
+++ b/tensorflow_serving/util/net_http/client/BUILD
@@ -0,0 +1,25 @@
+# Description: a lightweight http client
+
+package(
+    default_visibility = [
+        "//tensorflow_serving:internal",
+    ],
+    features = ["-layering_check"],
+)
+
+licenses(["notice"])  # Apache 2.0
+
+cc_library(
+    name = "evhttp_client",
+    srcs = [
+        "evhttp_connection.cc",
+    ],
+    hdrs = [
+        "evhttp_connection.h",
+    ],
+    deps = [
+        "@com_github_libevent_libevent//:libevent",
+        "@com_google_absl//absl/base",
+        "@com_google_absl//absl/strings",
+    ],
+)
diff --git a/tensorflow_serving/util/net_http/client/README.md b/tensorflow_serving/util/net_http/client/README.md
new file mode 100644
index 00000000000..394fab4437c
--- /dev/null
+++ b/tensorflow_serving/util/net_http/client/README.md
@@ -0,0 +1,3 @@
+The client library is still under development, and currently used for writing tests.
+
+The API specs are yet to be finalized.
\ No newline at end of file
diff --git a/tensorflow_serving/util/net_http/client/evhttp_connection.cc b/tensorflow_serving/util/net_http/client/evhttp_connection.cc
new file mode 100644
index 00000000000..0d50ce23d36
--- /dev/null
+++ b/tensorflow_serving/util/net_http/client/evhttp_connection.cc
@@ -0,0 +1,201 @@
+/* Copyright 2018 Google Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// libevent based client implementation
+
+#include "tensorflow_serving/util/net_http/client/evhttp_connection.h"
+
+#include "absl/base/internal/raw_logging.h"
+#include "absl/strings/str_cat.h"
+
+namespace tensorflow {
+namespace serving {
+namespace net_http {
+
+EvHTTPConnection::~EvHTTPConnection() {
+  if (evcon != nullptr) {
+    evhttp_connection_free(evcon);
+  }
+  if (http_uri != nullptr) {
+    evhttp_uri_free(http_uri);
+  }
+
+  event_base_free(ev_base);
+}
+
+std::unique_ptr<EvHTTPConnection> EvHTTPConnection::Connect(
+    absl::string_view url) {
+  std::string url_str(url.data(), url.size());
+  struct evhttp_uri* http_uri = evhttp_uri_parse(url_str.c_str());
+  if (http_uri == nullptr) {
+    ABSL_RAW_LOG(ERROR, "Failed to connect : event_base_new()");
+    return nullptr;
+  }
+
+  const char* host = evhttp_uri_get_host(http_uri);
+  if (host == nullptr) {
+    ABSL_RAW_LOG(ERROR, "url must have a host %.*s",
+                 static_cast<int>(url.size()), url.data());
+    return nullptr;
+  }
+
+  int port = evhttp_uri_get_port(http_uri);
+  if (port == -1) {
+    port = 80;
+  }
+
+  auto result = Connect(host, port);
+  evhttp_uri_free(http_uri);
+
+  return result;
+}
+
+std::unique_ptr<EvHTTPConnection> EvHTTPConnection::Connect(
+    absl::string_view host, int port) {
+  std::unique_ptr<EvHTTPConnection> result(new EvHTTPConnection());
+
+  result->ev_base = event_base_new();
+  if (result->ev_base == nullptr) {
+    ABSL_RAW_LOG(ERROR, "Failed to connect : event_base_new()");
+    return nullptr;
+  }
+
+  // blocking call (DNS resolution)
+  std::string host_str(host.data(), host.size());
+  result->evcon = evhttp_connection_base_bufferevent_new(
+      result->ev_base, nullptr, nullptr, host_str.c_str(),
+      static_cast<uint16_t>(port));
+  if (result->evcon == nullptr) {
+    ABSL_RAW_LOG(
+        ERROR, "Failed to connect : evhttp_connection_base_bufferevent_new()");
+    return nullptr;
+  }
+
+  evhttp_connection_set_retries(result->evcon, 0);
+
+  // TODO(wenboz): make this an option (default to 5s)
+  evhttp_connection_set_timeout(result->evcon, 5);
+
+  return result;
+}
+
+namespace {
+
+void response_cb(struct evhttp_request* req, void* ctx) {
+  ClientResponse* response = reinterpret_cast<ClientResponse*>(ctx);
+
+  if (req == nullptr) {
+    // TODO(wenboz): make this a util and check safety
+    int errcode = EVUTIL_SOCKET_ERROR();
+    ABSL_RAW_LOG(ERROR, "socket error = %s (%d)",
+                 evutil_socket_error_to_string(errcode), errcode);
+    return;
+  }
+
+  response->status = evhttp_request_get_response_code(req);
+
+  struct evkeyvalq* headers = evhttp_request_get_input_headers(req);
+  struct evkeyval* header;
+  for (header = headers->tqh_first; header; header = header->next.tqe_next) {
+    response->headers.emplace_back(header->key, header->value);
+  }
+
+  char buffer[1024];
+  int nread;
+
+  while ((nread = evbuffer_remove(evhttp_request_get_input_buffer(req), buffer,
+                                  sizeof(buffer))) > 0) {
+    absl::StrAppend(&response->body,
+                    absl::string_view(buffer, static_cast<size_t>(nread)));
+  }
+}
+
+evhttp_cmd_type GetMethodEnum(absl::string_view method, bool with_body) {
+  if (method.compare("GET") == 0) {
+    return EVHTTP_REQ_GET;
+  } else if (method.compare("POST") == 0) {
+    return EVHTTP_REQ_POST;
+  } else if (method.compare("HEAD") == 0) {
+    return EVHTTP_REQ_HEAD;
+  } else if (method.compare("PUT") == 0) {
+    return EVHTTP_REQ_PUT;
+  } else if (method.compare("DELETE") == 0) {
+    return EVHTTP_REQ_DELETE;
+  } else if (method.compare("OPTIONS") == 0) {
+    return EVHTTP_REQ_OPTIONS;
+  } else if (method.compare("TRACE") == 0) {
+    return EVHTTP_REQ_TRACE;
+  } else if (method.compare("CONNECT") == 0) {
+    return EVHTTP_REQ_CONNECT;
+  } else if (method.compare("PATCH") == 0) {
+    return EVHTTP_REQ_PATCH;
+  } else {
+    if (with_body) {
+      return EVHTTP_REQ_POST;
+    } else {
+      return EVHTTP_REQ_GET;
+    }
+  }
+}
+
+}  // namespace
+
+// Sends the request and has the connection closed
+bool EvHTTPConnection::SendRequest(const ClientRequest& request,
+                                   ClientResponse* response) {
+  struct evhttp_request* req = evhttp_request_new(response_cb, response);
+  if (req == nullptr) {
+    ABSL_RAW_LOG(ERROR, "Failed to send request : evhttp_request_new()");
+    return false;
+  }
+
+  struct evkeyvalq* output_headers = evhttp_request_get_output_headers(req);
+  for (auto header : request.headers) {
+    std::string key(header.first.data(), header.first.size());
+    std::string value(header.second.data(), header.second.size());
+    evhttp_add_header(output_headers, key.c_str(), value.c_str());
+  }
+
+  evhttp_add_header(output_headers, "Connection", "close");
+
+  if (!request.body.empty()) {
+    struct evbuffer* output_buffer = evhttp_request_get_output_buffer(req);
+
+    std::string body(request.body.data(), request.body.size());
+    evbuffer_add(output_buffer, body.c_str(), request.body.size());
+
+    char length_header[16];
+    evutil_snprintf(length_header, sizeof(length_header) - 1, "%lu",
+                    request.body.size());
+    evhttp_add_header(output_headers, "Content-Length", length_header);
+  }
+
+  std::string uri(request.uri_path.data(), request.uri_path.size());
+  int r = evhttp_make_request(
+      evcon, req, GetMethodEnum(request.method, !request.body.empty()),
+      uri.c_str());
+  if (r != 0) {
+    ABSL_RAW_LOG(ERROR, "evhttp_make_request() failed");
+    return false;
+  }
+
+  event_base_dispatch(ev_base);
+
+  return true;
+}
+
+}  // namespace net_http
+}  // namespace serving
+}  // namespace tensorflow
diff --git a/tensorflow_serving/util/net_http/client/evhttp_connection.h b/tensorflow_serving/util/net_http/client/evhttp_connection.h
new file mode 100644
index 00000000000..6f44b726af1
--- /dev/null
+++ b/tensorflow_serving/util/net_http/client/evhttp_connection.h
@@ -0,0 +1,100 @@
+/* Copyright 2018 Google Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// API for the HTTP client
+
+#ifndef TENSORFLOW_SERVING_UTIL_NET_HTTP_CLIENT_EVHTTP_CONNECTION_H_
+#define TENSORFLOW_SERVING_UTIL_NET_HTTP_CLIENT_EVHTTP_CONNECTION_H_
+
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "absl/strings/string_view.h"
+
+#include "libevent/include/event2/buffer.h"
+#include "libevent/include/event2/bufferevent.h"
+#include "libevent/include/event2/event.h"
+#include "libevent/include/event2/http.h"
+#include "libevent/include/event2/keyvalq_struct.h"
+#include "libevent/include/event2/util.h"
+
+namespace tensorflow {
+namespace serving {
+namespace net_http {
+
+// The following types may be moved to an API interface in future.
+
+// Data to be copied
+struct ClientRequest {
+  typedef std::pair<absl::string_view, absl::string_view> HeaderKeyValue;
+
+  absl::string_view uri_path;
+  absl::string_view method;  // must be in upper-case
+  std::vector<HeaderKeyValue> headers;
+  absl::string_view body;
+};
+
+// Caller allocates the data for output
+struct ClientResponse {
+  typedef std::pair<std::string, std::string> HeaderKeyValue;
+
+  int status = 0;
+  std::vector<HeaderKeyValue> headers;
+  std::string body;
+};
+
+class EvHTTPConnection final {
+ public:
+  ~EvHTTPConnection();
+
+  EvHTTPConnection(const EvHTTPConnection& other) = delete;
+  EvHTTPConnection& operator=(const EvHTTPConnection& other) = delete;
+
+  // Returns a new connection given an absolute URL.
+  // Always treat the URL scheme as "http" for now.
+  // Returns nullptr if any error
+  static std::unique_ptr<EvHTTPConnection> Connect(absl::string_view url);
+
+  // Returns a new connection to the specified host:port.
+  // Returns nullptr if any error
+  static std::unique_ptr<EvHTTPConnection> Connect(absl::string_view host,
+                                                   int port);
+
+  // Returns a new connection to the specified port of localhost.
+  // Returns nullptr if any error
+  static std::unique_ptr<EvHTTPConnection> ConnectLocal(int port) {
+    return Connect("localhost", port);
+  }
+
+  // Sends a request and blocks the caller till a response is received
+  // or any error has happened.
+  // Returns false if any error.
+  bool SendRequest(const ClientRequest& request, ClientResponse* response);
+
+ private:
+  EvHTTPConnection() = default;
+
+  struct event_base* ev_base;
+  struct evhttp_uri* http_uri;
+  struct evhttp_connection* evcon;
+};
+
+}  // namespace net_http
+}  // namespace serving
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_SERVING_UTIL_NET_HTTP_CLIENT_EVHTTP_CONNECTION_H_
diff --git a/tensorflow_serving/util/net_http/client/testing/BUILD b/tensorflow_serving/util/net_http/client/testing/BUILD
new file mode 100644
index 00000000000..d98fd2a7855
--- /dev/null
+++ b/tensorflow_serving/util/net_http/client/testing/BUILD
@@ -0,0 +1,18 @@
+# Description: net_http/client/testing
+
+package(
+    default_visibility = [
+        "//tensorflow_serving:internal",
+    ],
+    features = ["-layering_check"],
+)
+
+licenses(["notice"])  # Apache 2.0
+
+cc_binary(
+    name = "evhttp_echo_client",
+    srcs = ["evhttp_echo_client.cc"],
+    deps = [
+        "//tensorflow_serving/util/net_http/client:evhttp_client",
+    ],
+)
diff --git a/tensorflow_serving/util/net_http/client/testing/evhttp_echo_client.cc b/tensorflow_serving/util/net_http/client/testing/evhttp_echo_client.cc
new file mode 100644
index 00000000000..3fe804ce93e
--- /dev/null
+++ b/tensorflow_serving/util/net_http/client/testing/evhttp_echo_client.cc
@@ -0,0 +1,63 @@
+/* Copyright 2018 Google Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// A test client to print the response from the evhttp_echo_server
+// URI: /print
+
+#include <iostream>
+
+#include "tensorflow_serving/util/net_http/client/evhttp_connection.h"
+
+namespace {
+
+using tensorflow::serving::net_http::ClientRequest;
+using tensorflow::serving::net_http::ClientResponse;
+using tensorflow::serving::net_http::EvHTTPConnection;
+
+bool SendRequest(const char* url) {
+  auto connection = EvHTTPConnection::Connect(url);
+  if (connection == nullptr) {
+    std::cerr << "Fail to connect to %s" << url;
+  }
+
+  ClientRequest request = {url, "GET", {}, nullptr};
+  ClientResponse response;
+
+  if (!connection->SendRequest(request, &response)) {
+    std::cerr << "Request failed.";
+    return false;
+  }
+
+  std::cout << "Response received: " << std::endl
+            << "Status: " << response.status << std::endl;
+
+  for (auto keyval : response.headers) {
+    std::cout << keyval.first << " : " << keyval.second << std::endl;
+  }
+
+  std::cout << std::endl << response.body << std::endl;
+  return true;
+}
+
+}  // namespace
+
+int main(int argc, char** argv) {
+  if (argc < 2) {
+    std::cerr << "Usage: http-client <url>" << std::endl;
+    return 1;
+  }
+
+  return SendRequest(argv[1]);
+}
diff --git a/tensorflow_serving/util/net_http/server/internal/BUILD b/tensorflow_serving/util/net_http/server/internal/BUILD
new file mode 100644
index 00000000000..835a1569fcb
--- /dev/null
+++ b/tensorflow_serving/util/net_http/server/internal/BUILD
@@ -0,0 +1,61 @@
+# Description: implementations of HTTP Server
+
+package(
+    default_visibility = [
+        "//tensorflow_serving:internal",
+    ],
+    features = ["-layering_check"],
+)
+
+licenses(["notice"])  # Apache 2.0
+
+cc_library(
+    name = "evhttp_server",
+    srcs = [
+        "evhttp_request.cc",
+        "evhttp_server.cc",
+    ],
+    hdrs = [
+        "evhttp_request.h",
+        "evhttp_server.h",
+        "server_support.h",
+    ],
+    deps = [
+        "//tensorflow_serving/util/net_http/server/public:http_server_api",
+        "@com_github_libevent_libevent//:libevent",
+        "@com_google_absl//absl/base",
+        "@com_google_absl//absl/base:core_headers",
+        "@com_google_absl//absl/memory",
+        "@com_google_absl//absl/synchronization",
+    ],
+)
+
+cc_test(
+    name = "evhttp_server_test",
+    size = "medium",
+    srcs = ["evhttp_server_test.cc"],
+    deps = [
+        ":evhttp_server",
+        "//tensorflow_serving/core/test_util:test_main",
+        "//tensorflow_serving/util/net_http/client:evhttp_client",
+        "//tensorflow_serving/util/net_http/server/public:http_server",
+        "//tensorflow_serving/util/net_http/server/public:http_server_api",
+        "@com_google_absl//absl/memory",
+        "@com_google_absl//absl/synchronization:thread_pool",
+    ],
+)
+
+cc_test(
+    name = "evhttp_request_test",
+    size = "medium",
+    srcs = ["evhttp_request_test.cc"],
+    deps = [
+        ":evhttp_server",
+        "//tensorflow_serving/core/test_util:test_main",
+        "//tensorflow_serving/util/net_http/client:evhttp_client",
+        "//tensorflow_serving/util/net_http/server/public:http_server",
+        "//tensorflow_serving/util/net_http/server/public:http_server_api",
+        "@com_google_absl//absl/memory",
+        "@com_google_absl//absl/synchronization:thread_pool",
+    ],
+)
diff --git a/tensorflow_serving/util/net_http/server/internal/evhttp_request.cc b/tensorflow_serving/util/net_http/server/internal/evhttp_request.cc
new file mode 100644
index 00000000000..e30cc615e1d
--- /dev/null
+++ b/tensorflow_serving/util/net_http/server/internal/evhttp_request.cc
@@ -0,0 +1,261 @@
+/* Copyright 2018 Google Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// libevent based request implementation
+
+#include "tensorflow_serving/util/net_http/server/internal/evhttp_request.h"
+
+#include <cassert>
+#include <cstddef>
+#include <cstdint>
+#include <string>
+
+#include "absl/base/internal/raw_logging.h"
+
+#include "libevent/include/event2/buffer.h"
+#include "libevent/include/event2/event.h"
+#include "libevent/include/event2/http.h"
+#include "libevent/include/event2/keyvalq_struct.h"
+
+namespace tensorflow {
+namespace serving {
+namespace net_http {
+
+ParsedEvRequest::~ParsedEvRequest() {
+  if (decoded_uri) {
+    evhttp_uri_free(decoded_uri);
+  }
+
+  if (request && evhttp_request_is_owned(request)) {
+    evhttp_request_free(request);
+  }
+}
+
+ParsedEvRequest::ParsedEvRequest(evhttp_request* request_in)
+    : request(request_in) {}
+
+bool ParsedEvRequest::decode() {
+  switch (evhttp_request_get_command(request)) {
+    case EVHTTP_REQ_GET:
+      method = "GET";
+      break;
+    case EVHTTP_REQ_POST:
+      method = "POST";
+      break;
+    case EVHTTP_REQ_HEAD:
+      method = "HEAD";
+      break;
+    case EVHTTP_REQ_PUT:
+      method = "PUT";
+      break;
+    case EVHTTP_REQ_DELETE:
+      method = "DELETE";
+      break;
+    case EVHTTP_REQ_OPTIONS:
+      method = "OPTIONS";
+      break;
+    case EVHTTP_REQ_TRACE:
+      method = "TRACE";
+      break;
+    case EVHTTP_REQ_CONNECT:
+      method = "CONNECT";
+      break;
+    case EVHTTP_REQ_PATCH:
+      method = "PATCH";
+      break;
+    default:
+      return false;
+  }
+
+  uri = evhttp_request_get_uri(request);
+
+  decoded_uri = evhttp_uri_parse(uri);
+  if (decoded_uri == nullptr) {
+    return false;
+  }
+
+  // NB: need double-check "/" is OK
+  path = evhttp_uri_get_path(decoded_uri);
+  if (path == nullptr) {
+    path = "/";
+  }
+
+  headers = evhttp_request_get_input_headers(request);
+
+  return true;
+}
+
+EvHTTPRequest::EvHTTPRequest(std::unique_ptr<ParsedEvRequest> request,
+                             ServerSupport* server)
+    : server_(server),
+      parsed_request_(std::move(request)),
+      output_buf(nullptr) {}
+
+EvHTTPRequest::~EvHTTPRequest() {
+  if (output_buf != nullptr) {
+    evbuffer_free(output_buf);
+  }
+}
+
+absl::string_view EvHTTPRequest::uri_path() const {
+  return parsed_request_->path;
+}
+
+absl::string_view EvHTTPRequest::http_method() const {
+  return parsed_request_->method;
+}
+
+bool EvHTTPRequest::Initialize() {
+  output_buf = evbuffer_new();
+  return output_buf != nullptr;
+}
+
+void EvHTTPRequest::WriteResponseBytes(const char* data, int64_t size) {
+  assert(size >= 0);
+  if (output_buf == nullptr) {
+    ABSL_RAW_LOG(FATAL, "Request not initialized.");
+    return;
+  }
+
+  int ret = evbuffer_add(output_buf, data, static_cast<size_t>(size));
+  if (ret == -1) {
+    ABSL_RAW_LOG(ERROR, "Failed to write %zu bytes data to output buffer",
+                 static_cast<size_t>(size));
+  }
+}
+
+void EvHTTPRequest::WriteResponseString(absl::string_view data) {
+  WriteResponseBytes(data.data(), static_cast<int64_t>(data.size()));
+}
+
+std::unique_ptr<char, FreeDeleter> EvHTTPRequest::ReadRequestBytes(
+    int64_t* size) {
+  evbuffer* input_buf =
+      evhttp_request_get_input_buffer(parsed_request_->request);
+  if (input_buf == nullptr) {
+    return nullptr;  // nobody
+  }
+
+  size_t* buf_size = reinterpret_cast<size_t*>(size);
+
+  *buf_size = evbuffer_get_contiguous_space(input_buf);
+
+  if (*buf_size == 0) {
+    return nullptr;  // EOF
+  }
+
+  void* block = malloc(*buf_size);
+  int ret = evbuffer_remove(input_buf, block, *buf_size);
+
+  if (ret != *buf_size) {
+    ABSL_RAW_LOG(ERROR, "Unexpected: read less than specified num_bytes : %zu",
+                 *buf_size);
+  }
+
+  return std::unique_ptr<char, FreeDeleter>(static_cast<char*>(block));
+}
+
+// Note: passing string_view incurs a copy of underlying std::string data
+// (stack)
+absl::string_view EvHTTPRequest::GetRequestHeader(
+    absl::string_view header) const {
+  std::string header_str(header.data(), header.size());
+  return absl::string_view(
+      evhttp_find_header(parsed_request_->headers, header_str.c_str()));
+}
+
+std::vector<absl::string_view> EvHTTPRequest::request_headers() const {
+  auto result = std::vector<absl::string_view>();
+  auto ev_headers = parsed_request_->headers;
+
+  for (evkeyval* header = ev_headers->tqh_first; header;
+       header = header->next.tqe_next) {
+    result.push_back(absl::string_view(header->key));
+  }
+
+  return result;
+}
+
+void EvHTTPRequest::OverwriteResponseHeader(absl::string_view header,
+                                            absl::string_view value) {
+  evkeyvalq* ev_headers =
+      evhttp_request_get_output_headers(parsed_request_->request);
+
+  std::string header_str = std::string(header.data(), header.size());
+  const char* header_cstr = header_str.c_str();
+
+  evhttp_remove_header(ev_headers, header_cstr);
+  evhttp_add_header(ev_headers, header_cstr,
+                    std::string(value.data(), value.size()).c_str());
+}
+
+void EvHTTPRequest::AppendResponseHeader(absl::string_view header,
+                                         absl::string_view value) {
+  evkeyvalq* ev_headers =
+      evhttp_request_get_output_headers(parsed_request_->request);
+
+  int ret = evhttp_add_header(ev_headers,
+                              std::string(header.data(), header.size()).c_str(),
+                              std::string(value.data(), value.size()).c_str());
+
+  if (ret != 0) {
+    ABSL_RAW_LOG(ERROR,
+                 "Unexpected: failed to set the request header"
+                 " %.*s: %.*s",
+                 static_cast<int>(header.size()), header.data(),
+                 static_cast<int>(value.size()), value.data());
+  }
+}
+
+void EvHTTPRequest::PartialReplyWithStatus(HTTPStatusCode status) {
+  ABSL_RAW_LOG(FATAL, "PartialReplyWithStatus not implemented.");
+}
+
+void EvHTTPRequest::PartialReply() {
+  ABSL_RAW_LOG(FATAL, "PartialReplyWithStatus not implemented.");
+}
+
+void EvHTTPRequest::ReplyWithStatus(HTTPStatusCode status) {
+  bool result =
+      server_->EventLoopSchedule([this, status]() { EvSendReply(status); });
+
+  if (!result) {
+    ABSL_RAW_LOG(ERROR, "Failed to EventLoopSchedule ReplyWithStatus()");
+    Abort();
+    // TODO(wenboz): should have a forced abort that doesn't write back anything
+    // to the event-loop
+  }
+}
+
+void EvHTTPRequest::EvSendReply(HTTPStatusCode status) {
+  evhttp_send_reply(parsed_request_->request, static_cast<int>(status), nullptr,
+                    output_buf);
+  server_->DecOps();
+  delete this;
+}
+
+void EvHTTPRequest::Reply() { ReplyWithStatus(HTTPStatusCode::OK); }
+
+// Treats this as 500 for now and let libevent decide what to do
+// with the connection.
+void EvHTTPRequest::Abort() {
+  evhttp_send_error(parsed_request_->request, HTTP_INTERNAL, nullptr);
+  server_->DecOps();
+  delete this;
+}
+
+}  // namespace net_http
+}  // namespace serving
+}  // namespace tensorflow
diff --git a/tensorflow_serving/util/net_http/server/internal/evhttp_request.h b/tensorflow_serving/util/net_http/server/internal/evhttp_request.h
new file mode 100644
index 00000000000..96789103f31
--- /dev/null
+++ b/tensorflow_serving/util/net_http/server/internal/evhttp_request.h
@@ -0,0 +1,117 @@
+/* Copyright 2018 Google Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// libevent based request implementation
+
+#ifndef TENSORFLOW_SERVING_UTIL_NET_HTTP_SERVER_INTERNAL_EVHTTP_REQUEST_H_
+#define TENSORFLOW_SERVING_UTIL_NET_HTTP_SERVER_INTERNAL_EVHTTP_REQUEST_H_
+
+#include <cstdint>
+#include <memory>
+
+#include "tensorflow_serving/util/net_http/server/internal/server_support.h"
+#include "tensorflow_serving/util/net_http/server/public/serverrequestinterface.h"
+
+struct evbuffer;
+struct evhttp_request;
+struct evhttp_uri;
+struct evkeyvalq;
+
+namespace tensorflow {
+namespace serving {
+namespace net_http {
+
+// Headers only
+struct ParsedEvRequest {
+ public:
+  // Doesn't take the ownership
+  explicit ParsedEvRequest(evhttp_request* request_in);
+  ~ParsedEvRequest();
+
+  // Decode and cache the result; or return false if any parsing error
+  bool decode();
+
+  evhttp_request* request;  // raw request
+
+  const char* method;  // from enum
+
+  const char* uri = nullptr;          // from raw request
+  evhttp_uri* decoded_uri = nullptr;  // owned by this
+
+  // TODO(wenboz): do we need escaped path for dispatching requests?
+  // evhttp_uridecode(path)
+  const char* path = nullptr;  // owned by uri
+
+  evkeyvalq* headers = nullptr;  // owned by raw request
+};
+
+// Thread-compatible. See ServerRequestInterface on the exact contract
+// between the server runtime and application handlers.
+class EvHTTPRequest final : public ServerRequestInterface {
+ public:
+  virtual ~EvHTTPRequest();
+
+  EvHTTPRequest(const EvHTTPRequest& other) = delete;
+  EvHTTPRequest& operator=(const EvHTTPRequest& other) = delete;
+
+  // Doesn't own the server
+  EvHTTPRequest(std::unique_ptr<ParsedEvRequest> request,
+                ServerSupport* server);
+
+  absl::string_view uri_path() const override;
+
+  absl::string_view http_method() const override;
+
+  void WriteResponseBytes(const char* data, int64_t size) override;
+
+  void WriteResponseString(absl::string_view data) override;
+
+  std::unique_ptr<char, FreeDeleter> ReadRequestBytes(int64_t* size) override;
+
+  absl::string_view GetRequestHeader(absl::string_view header) const override;
+
+  std::vector<absl::string_view> request_headers() const override;
+
+  void OverwriteResponseHeader(absl::string_view header,
+                               absl::string_view value) override;
+  void AppendResponseHeader(absl::string_view header,
+                            absl::string_view value) override;
+
+  void PartialReplyWithStatus(HTTPStatusCode status) override;
+  void PartialReply() override;
+
+  void ReplyWithStatus(HTTPStatusCode status) override;
+  void Reply() override;
+
+  void Abort() override;
+
+  // Initializes the resource and returns false if any error.
+  bool Initialize();
+
+ private:
+  void EvSendReply(HTTPStatusCode status);
+
+  ServerSupport* server_;
+
+  std::unique_ptr<ParsedEvRequest> parsed_request_;
+
+  evbuffer* output_buf;  // owned by this
+};
+
+}  // namespace net_http
+}  // namespace serving
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_SERVING_UTIL_NET_HTTP_SERVER_INTERNAL_EVHTTP_REQUEST_H_
diff --git a/tensorflow_serving/util/net_http/server/internal/evhttp_request_test.cc b/tensorflow_serving/util/net_http/server/internal/evhttp_request_test.cc
new file mode 100644
index 00000000000..cb5e3ece18e
--- /dev/null
+++ b/tensorflow_serving/util/net_http/server/internal/evhttp_request_test.cc
@@ -0,0 +1,221 @@
+/* Copyright 2018 Google Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#include "tensorflow_serving/util/net_http/server/internal/evhttp_server.h"
+
+#include <cstdint>
+#include <memory>
+
+#include <gtest/gtest.h>
+
+#include "absl/memory/memory.h"
+#include "absl/synchronization/internal/thread_pool.h"
+
+#include "tensorflow_serving/util/net_http/client/evhttp_connection.h"
+#include "tensorflow_serving/util/net_http/server/public/httpserver.h"
+#include "tensorflow_serving/util/net_http/server/public/httpserverinterface.h"
+#include "tensorflow_serving/util/net_http/server/public/serverrequestinterface.h"
+
+namespace tensorflow {
+namespace serving {
+namespace net_http {
+namespace {
+
+class ThreadPool final : public EventExecutor {
+ public:
+  explicit ThreadPool(int num_threads) : thread_pool_(num_threads) {}
+
+  void Schedule(std::function<void()> fn) override {
+    thread_pool_.Schedule(fn);
+  }
+
+ private:
+  absl::synchronization_internal::ThreadPool thread_pool_;
+};
+
+class EvHTTPRequestTest : public ::testing::Test {
+ public:
+  void SetUp() override { InitServer(); }
+
+  void TearDown() override {
+    if (!server->is_terminating()) {
+      server->Terminate();
+      server->WaitForTermination();
+    }
+  }
+
+ protected:
+  std::unique_ptr<HTTPServerInterface> server;
+
+ private:
+  void InitServer() {
+    auto options = absl::make_unique<ServerOptions>();
+    options->AddPort(0);
+    options->SetExecutor(absl::make_unique<ThreadPool>(4));
+
+    server = CreateEvHTTPServer(std::move(options));
+
+    ASSERT_TRUE(server != nullptr);
+  }
+};
+
+// Test basic GET with 404
+TEST_F(EvHTTPRequestTest, SimpleGETNotFound) {
+  server->StartAcceptingRequests();
+
+  auto connection =
+      EvHTTPConnection::Connect("localhost", server->listen_port());
+  ASSERT_TRUE(connection != nullptr);
+
+  ClientRequest request = {"/noop", "GET", {}, nullptr};
+  ClientResponse response;
+
+  EXPECT_TRUE(connection->SendRequest(request, &response));
+  EXPECT_EQ(response.status, 404);
+  EXPECT_FALSE(response.body.empty());
+
+  server->Terminate();
+  server->WaitForTermination();
+}
+
+// Test basic GET with 200
+TEST_F(EvHTTPRequestTest, SimpleGETOK) {
+  auto handler = [](ServerRequestInterface* request) {
+    request->WriteResponseString("OK");
+    request->Reply();
+  };
+  server->RegisterRequestHandler("/ok", std::move(handler),
+                                 RequestHandlerOptions());
+  server->StartAcceptingRequests();
+
+  auto connection =
+      EvHTTPConnection::Connect("localhost", server->listen_port());
+  ASSERT_TRUE(connection != nullptr);
+
+  ClientRequest request = {"/ok", "GET", {}, nullptr};
+  ClientResponse response;
+
+  EXPECT_TRUE(connection->SendRequest(request, &response));
+  EXPECT_EQ(response.status, 200);
+  EXPECT_EQ(response.body, "OK");
+
+  server->Terminate();
+  server->WaitForTermination();
+}
+
+// Test basic POST with 200
+TEST_F(EvHTTPRequestTest, SimplePOST) {
+  auto handler = [](ServerRequestInterface* request) {
+    int64_t num_bytes;
+    auto request_chunk = request->ReadRequestBytes(&num_bytes);
+    while (request_chunk != nullptr) {
+      request->WriteResponseBytes(request_chunk.get(), num_bytes);
+      request_chunk = request->ReadRequestBytes(&num_bytes);
+    }
+    request->Reply();
+  };
+  server->RegisterRequestHandler("/ok", std::move(handler),
+                                 RequestHandlerOptions());
+  server->StartAcceptingRequests();
+
+  auto connection =
+      EvHTTPConnection::Connect("localhost", server->listen_port());
+  ASSERT_TRUE(connection != nullptr);
+
+  ClientRequest request = {"/ok", "POST", {}, "abcde"};
+  ClientResponse response;
+
+  EXPECT_TRUE(connection->SendRequest(request, &response));
+  EXPECT_EQ(response.status, 200);
+  EXPECT_EQ(response.body, "abcde");
+
+  server->Terminate();
+  server->WaitForTermination();
+}
+
+// Test request headers
+TEST_F(EvHTTPRequestTest, RequestHeaders) {
+  auto handler = [](ServerRequestInterface* request) {
+    EXPECT_GT(request->request_headers().size(), 2);
+    EXPECT_EQ(request->GetRequestHeader("H1"), "v1");
+    EXPECT_EQ(request->GetRequestHeader("h1"), "v1");
+    EXPECT_EQ(request->GetRequestHeader("H2"), "v2");
+    request->WriteResponseString("OK");
+    request->Reply();
+  };
+  server->RegisterRequestHandler("/ok", std::move(handler),
+                                 RequestHandlerOptions());
+  server->StartAcceptingRequests();
+
+  auto connection =
+      EvHTTPConnection::Connect("localhost", server->listen_port());
+  ASSERT_TRUE(connection != nullptr);
+
+  ClientRequest request = {"/ok",
+                           "GET",
+                           {ClientRequest::HeaderKeyValue("H1", "v1"),
+                            ClientRequest::HeaderKeyValue("H2", "v2")},
+                           nullptr};
+  ClientResponse response;
+
+  EXPECT_TRUE(connection->SendRequest(request, &response));
+  EXPECT_EQ(response.status, 200);
+  EXPECT_EQ(response.body, "OK");
+
+  server->Terminate();
+  server->WaitForTermination();
+}
+
+// Test response headers
+TEST_F(EvHTTPRequestTest, ResponseHeaders) {
+  auto handler = [](ServerRequestInterface* request) {
+    request->AppendResponseHeader("H1", "V1");
+    request->AppendResponseHeader("H2", "V2");
+    request->OverwriteResponseHeader("h2", "v2");
+    request->WriteResponseString("OK");
+    request->Reply();
+  };
+  server->RegisterRequestHandler("/ok", std::move(handler),
+                                 RequestHandlerOptions());
+  server->StartAcceptingRequests();
+
+  auto connection =
+      EvHTTPConnection::Connect("localhost", server->listen_port());
+  ASSERT_TRUE(connection != nullptr);
+
+  ClientRequest request = {"/ok", "GET", {}, nullptr};
+  ClientResponse response;
+
+  EXPECT_TRUE(connection->SendRequest(request, &response));
+  for (auto keyvalue : response.headers) {
+    if (keyvalue.first == "H1") {
+      EXPECT_EQ(keyvalue.second, "V1");
+    } else if (keyvalue.first == "H2") {
+      FAIL() << "H2 should have been overwritten by h2";
+    } else if (keyvalue.first == "h2") {
+      EXPECT_EQ(keyvalue.second, "v2");
+    }
+  }
+  EXPECT_EQ(response.status, 200);
+  EXPECT_EQ(response.body, "OK");
+
+  server->Terminate();
+  server->WaitForTermination();
+}
+
+}  // namespace
+}  // namespace net_http
+}  // namespace serving
+}  // namespace tensorflow
diff --git a/tensorflow_serving/util/net_http/server/internal/evhttp_server.cc b/tensorflow_serving/util/net_http/server/internal/evhttp_server.cc
new file mode 100644
index 00000000000..7c21c7d8ea6
--- /dev/null
+++ b/tensorflow_serving/util/net_http/server/internal/evhttp_server.cc
@@ -0,0 +1,368 @@
+/* Copyright 2018 Google Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// libevent based server implementation
+
+#include "tensorflow_serving/util/net_http/server/internal/evhttp_server.h"
+
+#include <netinet/in.h>
+#include <sys/socket.h>
+#include <cstdint>
+#include <memory>
+#include <utility>
+
+#include "absl/base/call_once.h"
+#include "absl/base/internal/raw_logging.h"
+#include "absl/memory/memory.h"
+
+#include "libevent/include/event2/event.h"
+#include "libevent/include/event2/http.h"
+#include "libevent/include/event2/thread.h"
+#include "libevent/include/event2/util.h"
+
+namespace tensorflow {
+namespace serving {
+namespace net_http {
+
+namespace {
+
+absl::once_flag libevent_init_once;
+
+void InitLibEvent() {
+  if (evthread_use_pthreads() != 0) {
+    ABSL_RAW_LOG(FATAL, "Server requires pthread support.");
+  }
+
+  // TODO(wenboz): windows support needed?
+}
+
+void GlobalInitialize() { absl::call_once(libevent_init_once, &InitLibEvent); }
+
+}  // namespace
+
+EvHTTPServer::EvHTTPServer(std::unique_ptr<ServerOptions> options)
+    : server_options_(std::move(options)), accepting_requests_() {}
+
+// May crash the server if called before WaitForTermination() returns
+EvHTTPServer::~EvHTTPServer() {
+  if (!is_terminating()) {
+    ABSL_RAW_LOG(ERROR,
+                 "Serer has not been terminated. Force termination now.");
+    Terminate();
+  }
+
+  if (ev_http_ != nullptr) {
+    // this frees the socket handlers too
+    evhttp_free(ev_http_);
+  }
+
+  if (ev_base_ != nullptr) {
+    event_base_free(ev_base_);
+  }
+}
+
+// Checks options.
+// TODO(wenboz): support multiple ports
+bool EvHTTPServer::Initialize() {
+  if (server_options_->executor() == nullptr) {
+    ABSL_RAW_LOG(FATAL, "Default EventExecutor is not configured.");
+    return false;
+  }
+
+  if (server_options_->ports().empty()) {
+    ABSL_RAW_LOG(FATAL, "Server port is not specified.");
+    return false;
+  }
+
+  GlobalInitialize();
+
+  // This ev_base_ created per-server v.s. global
+  ev_base_ = event_base_new();
+  if (ev_base_ == nullptr) {
+    ABSL_RAW_LOG(FATAL, "Failed to create an event_base.");
+    return false;
+  }
+
+  timeval tv_zero = {0, 0};
+  immediate_ = event_base_init_common_timeout(ev_base_, &tv_zero);
+
+  ev_http_ = evhttp_new(ev_base_);
+  if (ev_http_ == nullptr) {
+    ABSL_RAW_LOG(FATAL, "Failed to create evhttp.");
+    return false;
+  }
+
+  evhttp_set_gencb(ev_http_, &DispatchEvRequestFn, this);
+
+  return true;
+}
+
+// static function pointer
+void EvHTTPServer::DispatchEvRequestFn(evhttp_request* req, void* server) {
+  EvHTTPServer* http_server = static_cast<EvHTTPServer*>(server);
+  http_server->DispatchEvRequest(req);
+}
+
+void EvHTTPServer::DispatchEvRequest(evhttp_request* req) {
+  auto parsed_request = absl::make_unique<ParsedEvRequest>(req);
+
+  if (!parsed_request->decode()) {
+    evhttp_send_error(req, HTTP_BADREQUEST, nullptr);
+    return;
+  }
+
+  std::string path(parsed_request->path);
+
+  bool dispatched = false;
+  std::unique_ptr<EvHTTPRequest> ev_request(
+      new EvHTTPRequest(std::move(parsed_request), this));
+
+  if (!ev_request->Initialize()) {
+    evhttp_send_error(req, HTTP_SERVUNAVAIL, nullptr);
+    return;
+  }
+
+  {
+    absl::MutexLock l(&request_mu_);
+
+    auto handler_map_it = uri_handlers_.find(path);
+    if (handler_map_it != uri_handlers_.end()) {
+      IncOps();
+      dispatched = true;
+      ScheduleHandlerReference(handler_map_it->second.handler,
+                               ev_request.release());
+    }
+
+    if (!dispatched) {
+      for (const auto& dispatcher : dispatchers_) {
+        auto handler = dispatcher.dispatcher(ev_request.get());
+        if (handler == nullptr) {
+          continue;
+        }
+        IncOps();
+        dispatched = true;
+        ScheduleHandler(std::move(handler), ev_request.release());
+        break;
+      }
+    }
+  }
+
+  if (!dispatched) {
+    evhttp_send_error(req, HTTP_NOTFOUND, nullptr);
+    return;
+  }
+}
+
+void EvHTTPServer::ScheduleHandlerReference(const RequestHandler& handler,
+                                            EvHTTPRequest* ev_request) {
+  server_options_->executor()->Schedule(
+      [&handler, ev_request]() { handler(ev_request); });
+}
+
+// Exactly one copy of the handler argument
+// with the lambda passed by value to Schedule()
+void EvHTTPServer::ScheduleHandler(RequestHandler&& handler,
+                                   EvHTTPRequest* ev_request) {
+  server_options_->executor()->Schedule(
+      [handler, ev_request]() { handler(ev_request); });
+}
+
+namespace {
+
+void ResolveEphemeralPort(evhttp_bound_socket* listener, int* port) {
+  sockaddr_storage ss = {};
+  ev_socklen_t socklen = sizeof(ss);
+
+  evutil_socket_t fd = evhttp_bound_socket_get_fd(listener);
+  if (getsockname(fd, reinterpret_cast<sockaddr*>(&ss), &socklen)) {
+    ABSL_RAW_LOG(ERROR, "getsockname() failed");
+    return;
+  }
+
+  if (ss.ss_family == AF_INET) {
+    *port = ntohs((reinterpret_cast<sockaddr_in*>(&ss))->sin_port);
+  } else if (ss.ss_family == AF_INET6) {
+    *port = ntohs((reinterpret_cast<sockaddr_in6*>(&ss))->sin6_port);
+  } else {
+    ABSL_RAW_LOG(ERROR, "Unknown address family %d", ss.ss_family);
+  }
+}
+
+}  // namespace
+
+bool EvHTTPServer::StartAcceptingRequests() {
+  if (ev_http_ == nullptr) {
+    ABSL_RAW_LOG(FATAL, "Server has not been successfully initialized");
+    return false;
+  }
+
+  const int port = server_options_->ports().front();
+
+  ev_listener_ = evhttp_bind_socket_with_handle(ev_http_,
+                                                "::",  // in6addr_any
+                                                static_cast<ev_uint16_t>(port));
+  if (ev_listener_ == nullptr) {
+    ABSL_RAW_LOG(FATAL, "Couldn't bind to port %d", port);
+    return false;
+  }
+
+  port_ = port;
+  if (port_ == 0) {
+    ResolveEphemeralPort(ev_listener_, &port_);
+  }
+
+  server_options_->executor()->Schedule([this]() {
+    // This may race with event_base_loopexit if terminate()
+    // is called concurrently; and may block even after terminate() is called.
+    // This is to be addressed with a more rigid shutdown routine which
+    // will close all incoming connections after listener is deleted.
+    ABSL_RAW_LOG(INFO, "Entering the event loop ...");
+    int result = event_base_dispatch(ev_base_);
+    ABSL_RAW_LOG(INFO, "event_base_dispatch() exits with value %d", result);
+
+    DecOps();  // Unblock ~ctor
+  });
+
+  IncOps();
+
+  accepting_requests_.Notify();
+
+  return true;
+}
+
+int EvHTTPServer::listen_port() const { return port_; }
+
+bool EvHTTPServer::is_accepting_requests() const {
+  return accepting_requests_.HasBeenNotified();
+}
+
+void EvHTTPServer::Terminate() {
+  if (!is_accepting_requests()) {
+    ABSL_RAW_LOG(ERROR, "Server is not running ...");
+    return;
+  }
+
+  if (is_terminating()) {
+    ABSL_RAW_LOG(ERROR, "Server is already being terminated ...");
+    return;
+  }
+
+  terminating_.Notify();
+
+  // stop the listener first, which will delete ev_listener_
+  evhttp_del_accept_socket(ev_http_, ev_listener_);
+
+  int result = event_base_loopexit(ev_base_, nullptr);
+  ABSL_RAW_LOG(INFO, "event_base_loopexit() exits with value %d", result);
+
+  // Current shut-down behavior:
+  // - we don't proactively delete/close any HTTP connections as part of
+  //   Terminate(). This is not an issue as we don't support read-streaming yet.
+  // - we don't wait for all dispatched requests to run to completion
+  //   before we stop the event loop.
+  // - and otherwise, this is meant to be a clean shutdown
+}
+
+bool EvHTTPServer::is_terminating() const {
+  return terminating_.HasBeenNotified();
+}
+
+void EvHTTPServer::IncOps() {
+  absl::MutexLock l(&ops_mu_);
+  num_pending_ops_++;
+}
+
+void EvHTTPServer::DecOps() {
+  absl::MutexLock l(&ops_mu_);
+  num_pending_ops_--;
+}
+
+void EvHTTPServer::WaitForTermination() {
+  absl::MutexLock l(&ops_mu_);
+  ops_mu_.Await(absl::Condition(+[](int64_t* count) { return *count == 0; },
+                                &num_pending_ops_));
+}
+
+bool EvHTTPServer::WaitForTerminationWithTimeout(absl::Duration timeout) {
+  absl::MutexLock l(&ops_mu_);
+  return ops_mu_.AwaitWithTimeout(
+      absl::Condition(+[](int64_t* count) { return *count == 0; },
+                      &num_pending_ops_),
+      timeout);
+}
+
+EvHTTPServer::UriHandlerInfo::UriHandlerInfo(
+    absl::string_view uri_in, RequestHandler handler_in,
+    const RequestHandlerOptions& options_in)
+    : uri(uri_in.data(), uri_in.size()),
+      handler(std::move(handler_in)),
+      options(options_in) {}
+
+EvHTTPServer::DispatcherInfo::DispatcherInfo(
+    RequestDispatcher dispatcher_in, const RequestHandlerOptions& options_in)
+    : dispatcher(std::move(dispatcher_in)), options(options_in) {}
+
+void EvHTTPServer::RegisterRequestHandler(
+    absl::string_view uri, RequestHandler handler,
+    const RequestHandlerOptions& options) {
+  absl::MutexLock l(&request_mu_);
+  auto result = uri_handlers_.emplace(
+      std::piecewise_construct, std::forward_as_tuple(uri),
+      std::forward_as_tuple(uri, handler, options));
+
+  if (!result.second) {
+    ABSL_RAW_LOG(INFO,
+                 "Overwrite the existing handler registered under "
+                 "the URI path %.*s",
+                 static_cast<int>(uri.size()), uri.data());
+
+    uri_handlers_.erase(result.first);
+    if (!uri_handlers_
+             .emplace(std::piecewise_construct, std::forward_as_tuple(uri),
+                      std::forward_as_tuple(uri, handler, options))
+             .second) {
+      ABSL_RAW_LOG(ERROR,
+                   "Failed to register an handler under the URI path %.*s",
+                   static_cast<int>(uri.size()), uri.data());
+    }
+  }
+}
+
+void EvHTTPServer::RegisterRequestDispatcher(
+    RequestDispatcher dispatcher, const RequestHandlerOptions& options) {
+  absl::MutexLock l(&request_mu_);
+  dispatchers_.emplace_back(dispatcher, options);
+}
+
+namespace {
+
+void EvImmediateCallback(evutil_socket_t socket, int16_t flags, void* arg) {
+  auto fn = static_cast<std::function<void()>*>(arg);
+  (*fn)();
+  delete fn;
+}
+
+}  // namespace
+
+bool EvHTTPServer::EventLoopSchedule(std::function<void()> fn) {
+  auto scheduled_fn = new std::function<void()>(std::move(fn));
+  int result = event_base_once(ev_base_, -1, EV_TIMEOUT, EvImmediateCallback,
+                               static_cast<void*>(scheduled_fn), immediate_);
+  return result == 0;
+}
+
+}  // namespace net_http
+}  // namespace serving
+}  // namespace tensorflow
diff --git a/tensorflow_serving/util/net_http/server/internal/evhttp_server.h b/tensorflow_serving/util/net_http/server/internal/evhttp_server.h
new file mode 100644
index 00000000000..f5a0d13acaf
--- /dev/null
+++ b/tensorflow_serving/util/net_http/server/internal/evhttp_server.h
@@ -0,0 +1,143 @@
+/* Copyright 2018 Google Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// libevent based server implementation
+
+#ifndef TENSORFLOW_SERVING_UTIL_NET_HTTP_SERVER_INTERNAL_EVHTTP_SERVER_H_
+#define TENSORFLOW_SERVING_UTIL_NET_HTTP_SERVER_INTERNAL_EVHTTP_SERVER_H_
+
+#include <cstdint>
+#include <ctime>
+#include <memory>
+#include <unordered_map>
+#include <vector>
+
+#include "absl/base/thread_annotations.h"
+#include "absl/synchronization/mutex.h"
+
+#include "absl/synchronization/notification.h"
+
+#include "tensorflow_serving/util/net_http/server/internal/evhttp_request.h"
+#include "tensorflow_serving/util/net_http/server/internal/server_support.h"
+#include "tensorflow_serving/util/net_http/server/public/httpserverinterface.h"
+
+struct event_base;
+struct evhttp;
+struct evhttp_bound_socket;
+struct evhttp_request;
+
+namespace tensorflow {
+namespace serving {
+namespace net_http {
+
+class EvHTTPServer final : public HTTPServerInterface, ServerSupport {
+ public:
+  virtual ~EvHTTPServer();
+
+  EvHTTPServer(const EvHTTPServer& other) = delete;
+  EvHTTPServer& operator=(const EvHTTPServer& other) = delete;
+
+  explicit EvHTTPServer(std::unique_ptr<ServerOptions> options);
+
+  bool Initialize();
+
+  bool StartAcceptingRequests() override;
+
+  bool is_accepting_requests() const override;
+
+  int listen_port() const override;
+
+  void Terminate() override;
+
+  bool is_terminating() const override;
+
+  void WaitForTermination() override;
+
+  bool WaitForTerminationWithTimeout(absl::Duration timeout) override;
+
+  void RegisterRequestHandler(absl::string_view uri, RequestHandler handler,
+                              const RequestHandlerOptions& options) override;
+
+  void RegisterRequestDispatcher(RequestDispatcher dispatcher,
+                                 const RequestHandlerOptions& options) override;
+
+  void IncOps() override;
+  void DecOps() override;
+
+  bool EventLoopSchedule(std::function<void()> fn) override;
+
+ private:
+  static void DispatchEvRequestFn(struct evhttp_request* req, void* server);
+
+  void DispatchEvRequest(struct evhttp_request* req);
+
+  void ScheduleHandlerReference(const RequestHandler& handler,
+                                EvHTTPRequest* ev_request)
+      EXCLUSIVE_LOCKS_REQUIRED(request_mu_);
+  void ScheduleHandler(RequestHandler&& handler, EvHTTPRequest* ev_request)
+      EXCLUSIVE_LOCKS_REQUIRED(request_mu_);
+
+  struct UriHandlerInfo {
+   public:
+    UriHandlerInfo(absl::string_view uri_in, RequestHandler handler_in,
+                   const RequestHandlerOptions& options_in);
+    const std::string uri;
+    const RequestHandler handler;
+    const RequestHandlerOptions options;
+  };
+
+  struct DispatcherInfo {
+   public:
+    DispatcherInfo(RequestDispatcher dispatcher_in,
+                   const RequestHandlerOptions& options_in);
+
+    const RequestDispatcher dispatcher;
+    const RequestHandlerOptions options;
+  };
+
+  std::unique_ptr<ServerOptions> server_options_;
+
+  // Started accepting requests.
+  absl::Notification accepting_requests_;
+  // Listener port
+  int port_ = 0;
+
+  // Started terminating the server, i.e. Terminate() has been called
+  absl::Notification terminating_;
+
+  // Tracks the # of pending operations
+  mutable absl::Mutex ops_mu_;
+  int64_t num_pending_ops_ GUARDED_BY(ops_mu_) = 0;
+
+  mutable absl::Mutex request_mu_;
+  std::unordered_map<std::string, UriHandlerInfo> uri_handlers_
+      GUARDED_BY(request_mu_);
+  std::vector<DispatcherInfo> dispatchers_ GUARDED_BY(request_mu_);
+
+  // ev instances
+  event_base* ev_base_ = nullptr;
+  evhttp* ev_http_ = nullptr;
+  evhttp_bound_socket* ev_listener_ = nullptr;
+
+  // Timeval used to register immediate callbacks, which are called
+  // in the order that they are registered.
+  const timeval* immediate_;
+};
+
+}  // namespace net_http
+}  // namespace serving
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_SERVING_UTIL_NET_HTTP_SERVER_INTERNAL_EVHTTP_SERVER_H_
diff --git a/tensorflow_serving/util/net_http/server/internal/evhttp_server_test.cc b/tensorflow_serving/util/net_http/server/internal/evhttp_server_test.cc
new file mode 100644
index 00000000000..a1194cabbea
--- /dev/null
+++ b/tensorflow_serving/util/net_http/server/internal/evhttp_server_test.cc
@@ -0,0 +1,267 @@
+/* Copyright 2018 Google Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#include "tensorflow_serving/util/net_http/server/internal/evhttp_server.h"
+
+#include <memory>
+
+#include <gtest/gtest.h>
+
+#include "absl/memory/memory.h"
+#include "absl/synchronization/internal/thread_pool.h"
+
+#include "tensorflow_serving/util/net_http/client/evhttp_connection.h"
+#include "tensorflow_serving/util/net_http/server/public/httpserver.h"
+#include "tensorflow_serving/util/net_http/server/public/httpserverinterface.h"
+#include "tensorflow_serving/util/net_http/server/public/serverrequestinterface.h"
+
+namespace tensorflow {
+namespace serving {
+namespace net_http {
+namespace {
+
+class ThreadPool final : public EventExecutor {
+ public:
+  explicit ThreadPool(int num_threads) : thread_pool_(num_threads) {}
+
+  void Schedule(std::function<void()> fn) override {
+    thread_pool_.Schedule(fn);
+  }
+
+ private:
+  absl::synchronization_internal::ThreadPool thread_pool_;
+};
+
+class EvHTTPServerTest : public ::testing::Test {
+ public:
+  void SetUp() override { InitServer(); }
+
+  void TearDown() override {
+    if (!server->is_terminating()) {
+      server->Terminate();
+      server->WaitForTermination();
+    }
+  }
+
+ protected:
+  std::unique_ptr<HTTPServerInterface> server;
+
+ private:
+  void InitServer() {
+    auto options = absl::make_unique<ServerOptions>();
+    options->AddPort(0);
+    options->SetExecutor(absl::make_unique<ThreadPool>(4));
+
+    server = CreateEvHTTPServer(std::move(options));
+
+    ASSERT_TRUE(server != nullptr);
+  }
+};
+
+// Test StartAcceptingRequests
+TEST_F(EvHTTPServerTest, AcceptingTerminating) {
+  EXPECT_FALSE(server->is_accepting_requests());
+  server->StartAcceptingRequests();
+  EXPECT_TRUE(server->is_accepting_requests());
+
+  server->Terminate();
+  EXPECT_TRUE(server->is_terminating());
+
+  server->WaitForTermination();
+}
+
+// Test the path matching behavior
+TEST_F(EvHTTPServerTest, ExactPathMatching) {
+  auto handler = [](ServerRequestInterface* request) {
+    request->WriteResponseString("OK");
+    request->Reply();
+  };
+  server->RegisterRequestHandler("/ok", std::move(handler),
+                                 RequestHandlerOptions());
+  server->StartAcceptingRequests();
+
+  auto connection =
+      EvHTTPConnection::Connect("localhost", server->listen_port());
+  ASSERT_TRUE(connection != nullptr);
+
+  ClientRequest request = {"/ok?a=foo", "GET", {}, nullptr};
+  ClientResponse response;
+
+  EXPECT_TRUE(connection->SendRequest(request, &response));
+  EXPECT_EQ(response.status, 200);
+  EXPECT_EQ(response.body, "OK");
+
+  // no canonicalization for the trailing "/"
+  request = {"/ok/", "GET", {}, nullptr};
+  response = {};
+
+  EXPECT_TRUE(connection->SendRequest(request, &response));
+  EXPECT_EQ(response.status, 404);
+
+  server->Terminate();
+  server->WaitForTermination();
+}
+
+// Test RequestHandler overwriting
+TEST_F(EvHTTPServerTest, RequestHandlerOverwriting) {
+  auto handler1 = [](ServerRequestInterface* request) {
+    request->WriteResponseString("OK1");
+    request->Reply();
+  };
+  auto handler2 = [](ServerRequestInterface* request) {
+    request->WriteResponseString("OK2");
+    request->Reply();
+  };
+
+  server->RegisterRequestHandler("/ok", std::move(handler1),
+                                 RequestHandlerOptions());
+  server->RegisterRequestHandler("/ok", std::move(handler2),
+                                 RequestHandlerOptions());
+  server->StartAcceptingRequests();
+
+  auto connection =
+      EvHTTPConnection::Connect("localhost", server->listen_port());
+  ASSERT_TRUE(connection != nullptr);
+
+  ClientRequest request = {"/ok", "GET", {}, nullptr};
+  ClientResponse response;
+
+  EXPECT_TRUE(connection->SendRequest(request, &response));
+  EXPECT_EQ(response.status, 200);
+  EXPECT_EQ(response.body, "OK2");
+
+  server->Terminate();
+  server->WaitForTermination();
+}
+
+// Test single RequestDispatcher
+TEST_F(EvHTTPServerTest, SingleRequestDispather) {
+  auto handler = [](ServerRequestInterface* request) {
+    request->WriteResponseString("OK");
+    request->Reply();
+  };
+
+  auto dispatcher = [&handler](ServerRequestInterface* request) {
+    return handler;
+  };
+
+  server->RegisterRequestDispatcher(std::move(dispatcher),
+                                    RequestHandlerOptions());
+  server->StartAcceptingRequests();
+
+  auto connection =
+      EvHTTPConnection::Connect("localhost", server->listen_port());
+  ASSERT_TRUE(connection != nullptr);
+
+  ClientRequest request = {"/ok", "GET", {}, nullptr};
+  ClientResponse response;
+
+  EXPECT_TRUE(connection->SendRequest(request, &response));
+  EXPECT_EQ(response.status, 200);
+  EXPECT_EQ(response.body, "OK");
+
+  server->Terminate();
+  server->WaitForTermination();
+}
+
+// Test URI path precedes over RequestDispatcher
+TEST_F(EvHTTPServerTest, UriPrecedesOverRequestDispather) {
+  auto handler1 = [](ServerRequestInterface* request) {
+    request->WriteResponseString("OK1");
+    request->Reply();
+  };
+
+  server->RegisterRequestHandler("/ok", std::move(handler1),
+                                 RequestHandlerOptions());
+
+  auto handler2 = [](ServerRequestInterface* request) {
+    request->WriteResponseString("OK2");
+    request->Reply();
+  };
+
+  auto dispatcher = [&handler2](ServerRequestInterface* request) {
+    return handler2;
+  };
+  server->RegisterRequestDispatcher(std::move(dispatcher),
+                                    RequestHandlerOptions());
+
+  server->StartAcceptingRequests();
+
+  auto connection =
+      EvHTTPConnection::Connect("localhost", server->listen_port());
+  ASSERT_TRUE(connection != nullptr);
+
+  ClientRequest request = {"/ok", "GET", {}, nullptr};
+  ClientResponse response;
+
+  EXPECT_TRUE(connection->SendRequest(request, &response));
+  EXPECT_EQ(response.status, 200);
+  EXPECT_EQ(response.body, "OK1");
+
+  request = {"/okxx", "GET", {}, nullptr};
+  response = {};
+
+  EXPECT_TRUE(connection->SendRequest(request, &response));
+  EXPECT_EQ(response.status, 200);
+  EXPECT_EQ(response.body, "OK2");
+
+  server->Terminate();
+  server->WaitForTermination();
+}
+
+// Test RequestDispatcher in-order dispatching
+TEST_F(EvHTTPServerTest, InOrderRequestDispather) {
+  auto dispatcher1 = [](ServerRequestInterface* request) {
+    return [](ServerRequestInterface* request) {
+      request->WriteResponseString("OK1");
+      request->Reply();
+    };
+  };
+
+  auto dispatcher2 = [](ServerRequestInterface* request) {
+    return [](ServerRequestInterface* request) {
+      request->WriteResponseString("OK2");
+      request->Reply();
+    };
+  };
+
+  server->RegisterRequestDispatcher(std::move(dispatcher1),
+                                    RequestHandlerOptions());
+  server->RegisterRequestDispatcher(std::move(dispatcher2),
+                                    RequestHandlerOptions());
+
+  server->StartAcceptingRequests();
+
+  auto connection =
+      EvHTTPConnection::Connect("localhost", server->listen_port());
+  ASSERT_TRUE(connection != nullptr);
+
+  ClientRequest request = {"/ok", "GET", {}, nullptr};
+  ClientResponse response;
+
+  EXPECT_TRUE(connection->SendRequest(request, &response));
+  EXPECT_EQ(response.status, 200);
+  EXPECT_EQ(response.body, "OK1");
+
+  server->Terminate();
+  server->WaitForTermination();
+}
+
+// TODO(wenboz): More tests on clean shutdown
+
+}  // namespace
+}  // namespace net_http
+}  // namespace serving
+}  // namespace tensorflow
diff --git a/tensorflow_serving/util/net_http/server/internal/server_support.h b/tensorflow_serving/util/net_http/server/internal/server_support.h
new file mode 100644
index 00000000000..35092a2525d
--- /dev/null
+++ b/tensorflow_serving/util/net_http/server/internal/server_support.h
@@ -0,0 +1,54 @@
+/* Copyright 2018 Google Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// This pure interface provides callbacks from a request object to the
+// server object so the two are properly decoupled.
+// This may turn out to be generally useful with no libevents specifics.
+
+#ifndef TENSORFLOW_SERVING_UTIL_NET_HTTP_SERVER_INTERNAL_SERVER_SUPPORT_H_
+#define TENSORFLOW_SERVING_UTIL_NET_HTTP_SERVER_INTERNAL_SERVER_SUPPORT_H_
+
+#include <functional>
+
+#include "tensorflow_serving/util/net_http/server/public/serverrequestinterface.h"
+
+namespace tensorflow {
+namespace serving {
+namespace net_http {
+
+class ServerSupport {
+ public:
+  virtual ~ServerSupport() = default;
+
+  ServerSupport(const ServerSupport& other) = delete;
+  ServerSupport& operator=(const ServerSupport& other) = delete;
+
+  // book-keeping of active requests
+  virtual void IncOps() = 0;
+  virtual void DecOps() = 0;
+
+  // Schedules the callback function to run immediately from the event loop.
+  // Returns false if any error.
+  virtual bool EventLoopSchedule(std::function<void()> fn) = 0;
+
+ protected:
+  ServerSupport() = default;
+};
+
+}  // namespace net_http
+}  // namespace serving
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_SERVING_UTIL_NET_HTTP_SERVER_INTERNAL_SERVER_SUPPORT_H_
diff --git a/tensorflow_serving/util/net_http/server/public/BUILD b/tensorflow_serving/util/net_http/server/public/BUILD
new file mode 100644
index 00000000000..895d9072de5
--- /dev/null
+++ b/tensorflow_serving/util/net_http/server/public/BUILD
@@ -0,0 +1,36 @@
+# Description: a lightweight http server and related utils to support Web clients
+
+package(
+    default_visibility = [
+        "//tensorflow_serving:internal",
+    ],
+    features = ["-layering_check"],
+)
+
+licenses(["notice"])  # Apache 2.0
+
+cc_library(
+    name = "http_server_api",
+    hdrs = [
+        "httpserverinterface.h",
+        "response_code_enum.h",
+        "serverrequestinterface.h",
+    ],
+    deps = [
+        "@com_google_absl//absl/strings",
+        "@com_google_absl//absl/time",
+    ],
+)
+
+cc_library(
+    name = "http_server",
+    hdrs = [
+        "httpserver.h",
+    ],
+    deps = [
+        ":http_server_api",
+        "//tensorflow_serving/util/net_http/server/internal:evhttp_server",
+        "@com_google_absl//absl/base",
+        "@com_google_absl//absl/memory",
+    ],
+)
diff --git a/tensorflow_serving/util/net_http/server/public/httpserver.h b/tensorflow_serving/util/net_http/server/public/httpserver.h
new file mode 100644
index 00000000000..a601f3d1a4b
--- /dev/null
+++ b/tensorflow_serving/util/net_http/server/public/httpserver.h
@@ -0,0 +1,54 @@
+/* Copyright 2018 Google Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// The entry point to access different HTTP server implementations.
+
+#ifndef TENSORFLOW_SERVING_UTIL_NET_HTTP_SERVER_PUBLIC_HTTPSERVER_H_
+#define TENSORFLOW_SERVING_UTIL_NET_HTTP_SERVER_PUBLIC_HTTPSERVER_H_
+
+#include <memory>
+
+#include "absl/base/internal/raw_logging.h"
+#include "absl/memory/memory.h"
+
+#include "tensorflow_serving/util/net_http/server/internal/evhttp_server.h"
+#include "tensorflow_serving/util/net_http/server/public/httpserverinterface.h"
+
+namespace tensorflow {
+namespace serving {
+namespace net_http {
+
+// Creates a server implemented based on the libevents library.
+// Returns nullptr if there is any error.
+//
+// Must call WaitForTermination() or WaitForTerminationWithTimeout() before
+// the server is to be destructed.
+inline std::unique_ptr<HTTPServerInterface> CreateEvHTTPServer(
+    std::unique_ptr<ServerOptions> options) {
+  auto server = absl::make_unique<EvHTTPServer>(std::move(options));
+  bool result = server->Initialize();
+  if (!result) {
+    ABSL_RAW_LOG(ERROR, "Failed to initialize EvHTTPServer");
+    return nullptr;
+  }
+
+  return std::move(server);
+}
+
+}  // namespace net_http
+}  // namespace serving
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_SERVING_UTIL_NET_HTTP_SERVER_PUBLIC_HTTPSERVER_H_
diff --git a/tensorflow_serving/util/net_http/server/public/httpserverinterface.h b/tensorflow_serving/util/net_http/server/public/httpserverinterface.h
new file mode 100644
index 00000000000..674b82b3fdb
--- /dev/null
+++ b/tensorflow_serving/util/net_http/server/public/httpserverinterface.h
@@ -0,0 +1,176 @@
+/* Copyright 2018 Google Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// APIs for the HTTP server.
+
+#ifndef TENSORFLOW_SERVING_UTIL_NET_HTTP_SERVER_PUBLIC_HTTPSERVERINTERFACE_H_
+#define TENSORFLOW_SERVING_UTIL_NET_HTTP_SERVER_PUBLIC_HTTPSERVERINTERFACE_H_
+
+#include <cassert>
+
+#include <functional>
+#include <memory>
+#include <vector>
+
+#include "absl/strings/string_view.h"
+#include "absl/time/time.h"
+
+#include "tensorflow_serving/util/net_http/server/public/serverrequestinterface.h"
+
+namespace tensorflow {
+namespace serving {
+namespace net_http {
+
+// A strictly non-blocking executor for processing I/O polling or callback
+// events.
+class EventExecutor {
+ public:
+  virtual ~EventExecutor() = default;
+
+  EventExecutor(const EventExecutor& other) = delete;
+  EventExecutor& operator=(const EventExecutor& other) = delete;
+
+  // Schedule the specified 'fn' for execution in this executor.
+  // Must be non-blocking
+  virtual void Schedule(std::function<void()> fn) = 0;
+
+ protected:
+  EventExecutor() = default;
+};
+
+// Options to specify when a server instance is created.
+class ServerOptions {
+ public:
+  ServerOptions() = default;
+
+  // At least one port has to be configured.
+  void AddPort(int port) {
+    assert(port >= 0);
+    ports_.emplace_back(port);
+  }
+
+  // The default executor for running I/O event polling.
+  // This is a mandatory option.
+  void SetExecutor(std::unique_ptr<EventExecutor> executor) {
+    executor_ = std::move(executor);
+  }
+
+  const std::vector<int>& ports() { return ports_; }
+
+  EventExecutor* executor() { return executor_.get(); }
+
+ private:
+  std::vector<int> ports_;
+  std::unique_ptr<EventExecutor> executor_;
+};
+
+// Options to specify when registering a handler (given a uri pattern).
+// This should be a value type.
+class RequestHandlerOptions {
+ public:
+  RequestHandlerOptions() = default;
+
+ private:
+  // Potential options: compression, CORS rules, streaming control
+  // thread executor, admission control, limits ...
+  // with public setter/getters.
+};
+
+// A request handler is registered by the application to handle a request
+// based on the request Uri path, available via ServerRequestInterface.
+//
+// Request handlers need be completely non-blocking. And handlers may add
+// callbacks to a thread-pool that is managed by the application itself.
+typedef std::function<void(ServerRequestInterface*)> RequestHandler;
+
+// Returns a nullptr if the request is not handled by this dispatcher.
+typedef std::function<RequestHandler(ServerRequestInterface*)>
+    RequestDispatcher;
+
+// This interface class specifies the API contract for the HTTP server.
+//
+// Requirements for implementations:
+// - must be thread-safe
+// - multiple HTTP server instances need be supported in a single process
+// - for a basic implementation, the application needs provide a dedicated
+//   thread to handle all I/O events, i.e. the thread that calls
+//   StartAcceptingRequests().
+// - the arrival order of concurrent requests is insignificant because the
+//   server runtime and I/O are completely event-driven.
+class HTTPServerInterface {
+ public:
+  virtual ~HTTPServerInterface() = default;
+
+  HTTPServerInterface(const HTTPServerInterface& other) = delete;
+  HTTPServerInterface& operator=(const HTTPServerInterface& other) = delete;
+
+  // Starts to accept requests arrived on the network.
+  // Returns false if the server runtime fails to initialize properly.
+  virtual bool StartAcceptingRequests() = 0;
+
+  // Returns true if StartAcceptingRequests() has been called.
+  virtual bool is_accepting_requests() const = 0;
+
+  // Returns the server listener port if any, or else returns 0.
+  virtual int listen_port() const = 0;
+
+  // Starts the server termination, and returns immediately.
+  virtual void Terminate() = 0;
+
+  // Returns true if Terminate() has been called.
+  virtual bool is_terminating() const = 0;
+
+  // Blocks the calling thread until the server is terminated and safe
+  // to destroy.
+  virtual void WaitForTermination() = 0;
+
+  // Blocks the calling thread until the server is terminated and safe
+  // to destroy, or until the specified timeout elapses.  Returns true
+  // if safe termination completed within the timeout, and false otherwise.
+  virtual bool WaitForTerminationWithTimeout(absl::Duration timeout) = 0;
+
+  // To be specified: lameduck
+
+  // Registers a request handler with exact URI path matching.
+  // Any existing handler under the same uri will be overwritten.
+  // The server owns the handler after registration.
+  // Handlers may be registered after the server has been started.
+  virtual void RegisterRequestHandler(absl::string_view uri,
+                                      RequestHandler handler,
+                                      const RequestHandlerOptions& options) = 0;
+
+  // Registers a request dispatcher, i.e. application-provided URI dispatching
+  // logic, e.g. a regexp based one.
+  //
+  // For a given request, dispatchers are only invoked if there is no exact URI
+  // path matching to any registered request handler.
+  //
+  // Dispatchers are invoked in order of registration, i.e. first registered
+  // gets first pick. The server owns the dispatcher after registration.
+  // Dispatchers may be registered after the server has been started.
+  virtual void RegisterRequestDispatcher(
+      RequestDispatcher dispatcher, const RequestHandlerOptions& options) = 0;
+
+  // To be added: unregister (if needed)
+
+ protected:
+  HTTPServerInterface() = default;
+};
+
+}  // namespace net_http
+}  // namespace serving
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_SERVING_UTIL_NET_HTTP_SERVER_PUBLIC_HTTPSERVERINTERFACE_H_
diff --git a/tensorflow_serving/util/net_http/server/public/response_code_enum.h b/tensorflow_serving/util/net_http/server/public/response_code_enum.h
new file mode 100644
index 00000000000..b678c7ac495
--- /dev/null
+++ b/tensorflow_serving/util/net_http/server/public/response_code_enum.h
@@ -0,0 +1,113 @@
+/* Copyright 2018 Google Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_SERVING_UTIL_NET_HTTP_SERVER_PUBLIC_RESPONSE_CODE_ENUM_H_
+#define TENSORFLOW_SERVING_UTIL_NET_HTTP_SERVER_PUBLIC_RESPONSE_CODE_ENUM_H_
+
+namespace tensorflow {
+namespace serving {
+namespace net_http {
+
+enum class HTTPStatusCode {
+  // These are the status codes we can give back to the client.
+  // http://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml#http-status-codes-1
+  UNDEFINED = 0,  // Illegal value for initialization
+  FIRST_CODE = 100,
+
+  // Informational
+  CONTINUE = 100,    // Continue
+  SWITCHING = 101,   // Switching Protocols
+  PROCESSING = 102,  // Processing (RFC 2518, sec 10.1)
+
+  // Success
+  OK = 200,                // OK
+  CREATED = 201,           // Created
+  ACCEPTED = 202,          // Accepted
+  PROVISIONAL = 203,       // Non-Authoritative Information
+  NO_CONTENT = 204,        // No Content
+  RESET_CONTENT = 205,     // Reset Content
+  PART_CONTENT = 206,      // Partial Content
+  MULTI_STATUS = 207,      // Multi-Status (RFC 2518, sec 10.2)
+  ALREADY_REPORTED = 208,  // Already Reported (RFC 5842)
+  IM_USED = 226,           // IM Used (RFC 3229)
+
+  // Redirect
+  MULTIPLE = 300,           // Multiple Choices
+  MOVED_PERM = 301,         // Moved Permanently
+  MOVED_TEMP = 302,         // Found. For historical reasons,
+                            // a user agent MAY change the method
+                            // from POST to GET for the subsequent
+                            // request (RFC 7231, sec 6.4.3).
+  SEE_OTHER = 303,          // See Other
+  NOT_MODIFIED = 304,       // Not Modified
+  USE_PROXY = 305,          // Use Proxy
+  TEMP_REDIRECT = 307,      // Similar to 302, except that user
+                            // agents MUST NOT change the request
+                            // method (RFC 7231, sec 6.4.7)
+  RESUME_INCOMPLETE = 308,  // Resume Incomplete
+
+  // Client Error
+  BAD_REQUEST = 400,            // Bad Request
+  UNAUTHORIZED = 401,           // Unauthorized
+  PAYMENT = 402,                // Payment Required
+  FORBIDDEN = 403,              // Forbidden
+  NOT_FOUND = 404,              // Not Found
+  METHOD_NA = 405,              // Method Not Allowed
+  NONE_ACC = 406,               // Not Acceptable
+  PROXY = 407,                  // Proxy Authentication Required
+  REQUEST_TO = 408,             // Request Time-out
+  CONFLICT = 409,               // Conflict
+  GONE = 410,                   // Gone
+  LEN_REQUIRED = 411,           // Length Required
+  PRECOND_FAILED = 412,         // Precondition Failed
+  ENTITY_TOO_BIG = 413,         // Request Entity Too Large
+  URI_TOO_BIG = 414,            // Request-URI Too Large
+  UNKNOWN_MEDIA = 415,          // Unsupported Media Type
+  BAD_RANGE = 416,              // Requested range not satisfiable
+  BAD_EXPECTATION = 417,        // Expectation Failed
+  IM_A_TEAPOT = 418,            // I'm a Teapot (RFC 2324, 7168)
+  MISDIRECTED_REQUEST = 421,    // Misdirected Request (RFC 7540)
+  UNPROC_ENTITY = 422,          // Unprocessable Entity (RFC 2518, sec 10.3)
+  LOCKED = 423,                 // Locked (RFC 2518, sec 10.4)
+  FAILED_DEP = 424,             // Failed Dependency (RFC 2518, sec 10.5)
+  UPGRADE_REQUIRED = 426,       // Upgrade Required (RFC 7231, sec 6.5.14)
+  PRECOND_REQUIRED = 428,       // Precondition Required (RFC 6585, sec 3)
+  TOO_MANY_REQUESTS = 429,      // Too Many Requests (RFC 6585, sec 4)
+  HEADER_TOO_LARGE = 431,       // Request Header Fields Too Large
+                                // (RFC 6585, sec 5)
+  UNAVAILABLE_LEGAL = 451,      // Unavailable For Legal Reasons (RFC 7725)
+  CLIENT_CLOSED_REQUEST = 499,  // Client Closed Request (Nginx)
+
+  // Server Error
+  ERROR = 500,               // Internal Server Error
+  NOT_IMP = 501,             // Not Implemented
+  BAD_GATEWAY = 502,         // Bad Gateway
+  SERVICE_UNAV = 503,        // Service Unavailable
+  GATEWAY_TO = 504,          // Gateway Time-out
+  BAD_VERSION = 505,         // HTTP Version not supported
+  VARIANT_NEGOTIATES = 506,  // Variant Also Negotiates (RFC 2295)
+  INSUF_STORAGE = 507,       // Insufficient Storage (RFC 2518, sec 10.6)
+  LOOP_DETECTED = 508,       // Loop Detected (RFC 5842)
+  NOT_EXTENDED = 510,        // Not Extended (RFC 2774)
+  NETAUTH_REQUIRED = 511,    // Network Authentication Required
+                             // (RFC 6585, sec 6)
+  LAST_CODE = 599,
+};
+
+}  // namespace net_http
+}  // namespace serving
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_SERVING_UTIL_NET_HTTP_SERVER_PUBLIC_RESPONSE_CODE_ENUM_H_
diff --git a/tensorflow_serving/util/net_http/server/public/serverrequestinterface.h b/tensorflow_serving/util/net_http/server/public/serverrequestinterface.h
new file mode 100644
index 00000000000..12d9f69ba98
--- /dev/null
+++ b/tensorflow_serving/util/net_http/server/public/serverrequestinterface.h
@@ -0,0 +1,163 @@
+/* Copyright 2018 Google Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// net_http::ServerRequestInterface defines a pure interface class for handling
+// an HTTP request on the server-side. It is designed as a minimum API
+// to ensure reusability and to work with different HTTP implementations.
+//
+// ServerRequestInterface is thread-compatible. Once the request object
+// has been dispatched to the application-specified handler, the HTTP server
+// runtime will not access the request object till Reply() is called.
+//
+// Streamed request/response APIs are to be added, which will introduce
+// additional API contract wrt the threading semantics.
+
+#ifndef TENSORFLOW_SERVING_UTIL_NET_HTTP_SERVER_PUBLIC_SERVERREQUESTINTERFACE_H_
+#define TENSORFLOW_SERVING_UTIL_NET_HTTP_SERVER_PUBLIC_SERVERREQUESTINTERFACE_H_
+
+#include <cstdint>
+#include <cstdlib>
+#include <memory>
+#include <vector>
+
+#include "absl/strings/string_view.h"
+
+#include "tensorflow_serving/util/net_http/server/public/response_code_enum.h"
+
+namespace tensorflow {
+namespace serving {
+namespace net_http {
+
+// To be used with std::unique_ptr<char>
+struct FreeDeleter {
+  inline void operator()(char* ptr) const { free(ptr); }
+};
+
+class ServerRequestInterface {
+ public:
+  virtual ~ServerRequestInterface() = default;
+
+  ServerRequestInterface(const ServerRequestInterface& other) = delete;
+  ServerRequestInterface& operator=(const ServerRequestInterface& other) =
+      delete;
+
+  // The relative portion of the request URI (without host).
+  // No escape decoding.
+  virtual absl::string_view uri_path() const = 0;
+
+  // HTTP request method.
+  // Must be in Upper Case.
+  virtual absl::string_view http_method() const = 0;
+
+  // Input/output byte-buffer types are subject to change!
+  // I/O buffer choices:
+  // - absl:ByteStream would work but it is not yet open-sourced
+  // - iovec doesn't add much value and may limit portability; but otherwise
+  //   the current API is compatible with iovec
+  // - absl::Span is open-sourced, but string_view is simpler to use for writing
+  //   to an HTTP response.
+
+  // Appends the data block of the specified size to the response body.
+  // This request object takes the ownership of the data block.
+  //
+  // Note this is not a streaming write API. See PartialReply() below.
+  virtual void WriteResponseBytes(const char* data, int64_t size) = 0;
+
+  // Appends (by coping) the data of string_view to the end of
+  // the response body.
+  virtual void WriteResponseString(absl::string_view data) = 0;
+
+  // Reads from the request body.
+  // Returns the number bytes of data read, whose ownership will be transferred
+  // to the caller. Returns nullptr when EOF is reached or when there
+  // is no request body.
+  //
+  // The returned memory will be "free-ed" via the custom Deleter.
+  //
+  // Note this is not a streaming read API in that the complete request body
+  // should have already been received.
+  virtual std::unique_ptr<char, FreeDeleter> ReadRequestBytes(
+      int64_t* size) = 0;
+
+  // Returns the first value, including "", associated with a request
+  // header name. The header name argument is case-insensitive.
+  // Returns nullptr if the specified header doesn't exist.
+  virtual absl::string_view GetRequestHeader(
+      absl::string_view header) const = 0;
+
+  // To be added: multi-value headers.
+
+  // Returns all the request header names.
+  // This is not an efficient way to access headers, mainly for debugging uses.
+  virtual std::vector<absl::string_view> request_headers() const = 0;
+
+  virtual void OverwriteResponseHeader(absl::string_view header,
+                                       absl::string_view value) = 0;
+  virtual void AppendResponseHeader(absl::string_view header,
+                                    absl::string_view value) = 0;
+
+  // Sends headers and/or any buffered response body data to the client.
+  // Assumes 200 if status is not specified.
+  // If called for the first time, all the response headers will be sent
+  // together including headers specified by the application and
+  // headers generated by the server.
+  // Trying to modify headers or specifying a status after the first
+  // PartialReply() is called is considered a programming error.
+  virtual void PartialReplyWithStatus(HTTPStatusCode status) = 0;
+  virtual void PartialReply() = 0;
+
+  // Flow-control mechanism to be added
+
+  // Completes the response and sends any buffered response body
+  // to the client. Headers will be generated and sent first if PartialReply()
+  // has never be called.
+  // Assumes 200 if status is not specified.
+  // Once Reply() is called, the request object will be owned (and destructed)
+  // by the server runtime.
+  virtual void ReplyWithStatus(HTTPStatusCode status) = 0;
+  virtual void Reply() = 0;
+
+  // Aborts the current request forcibly.
+  virtual void Abort() = 0;
+
+  // To be defined: status enum
+
+ protected:
+  ServerRequestInterface() = default;
+
+ private:
+  // Do not add any data members to this class.
+};
+
+// Helper methods.
+
+inline void SetContentType(ServerRequestInterface* request,
+                           absl::string_view type) {
+  request->OverwriteResponseHeader("Content-Type", type);
+}
+
+inline void SetContentTypeHTML(ServerRequestInterface* request) {
+  SetContentType(request, "text/html");
+}
+
+inline void SetContentTypeTEXT(ServerRequestInterface* request) {
+  SetContentType(request, "text/plain");
+}
+
+}  // namespace net_http
+}  // namespace serving
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_SERVING_UTIL_NET_HTTP_SERVER_PUBLIC_SERVERREQUESTINTERFACE_H_
diff --git a/tensorflow_serving/util/net_http/server/testing/BUILD b/tensorflow_serving/util/net_http/server/testing/BUILD
new file mode 100644
index 00000000000..fff8ca0e3af
--- /dev/null
+++ b/tensorflow_serving/util/net_http/server/testing/BUILD
@@ -0,0 +1,20 @@
+# Description: net_http/server/testing
+
+package(
+    default_visibility = [
+        "//tensorflow_serving:internal",
+    ],
+    features = ["-layering_check"],
+)
+
+licenses(["notice"])  # Apache 2.0
+
+cc_binary(
+    name = "evhttp_echo_server",
+    srcs = ["evhttp_echo_server.cc"],
+    deps = [
+        "//tensorflow_serving/util/net_http/server/public:http_server",
+        "@com_google_absl//absl/memory",
+        "@com_google_absl//absl/strings",
+    ],
+)
diff --git a/tensorflow_serving/util/net_http/server/testing/evhttp_echo_server.cc b/tensorflow_serving/util/net_http/server/testing/evhttp_echo_server.cc
new file mode 100644
index 00000000000..d07f6bd0bdd
--- /dev/null
+++ b/tensorflow_serving/util/net_http/server/testing/evhttp_echo_server.cc
@@ -0,0 +1,144 @@
+/* Copyright 2018 Google Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// A single-threaded server to print the request details as HTML
+// URI: /print
+
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+
+#include <iostream>
+#include <memory>
+#include <vector>
+
+#include "absl/memory/memory.h"
+#include "absl/strings/numbers.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/string_view.h"
+
+#include "tensorflow_serving/util/net_http/server/public/httpserver.h"
+#include "tensorflow_serving/util/net_http/server/public/httpserverinterface.h"
+#include "tensorflow_serving/util/net_http/server/public/serverrequestinterface.h"
+
+namespace {
+
+using absl::StrAppend;
+
+using tensorflow::serving::net_http::EventExecutor;
+using tensorflow::serving::net_http::HTTPServerInterface;
+using tensorflow::serving::net_http::RequestHandlerOptions;
+using tensorflow::serving::net_http::ServerOptions;
+using tensorflow::serving::net_http::ServerRequestInterface;
+using tensorflow::serving::net_http::SetContentTypeHTML;
+
+void EchoHandler(ServerRequestInterface* req) {
+  std::string response;
+
+  StrAppend(&response,
+            "<!DOCTYPE html>\n"
+            "<html>\n <head>\n"
+            "  <meta charset='utf-8'>\n"
+            "  <title>Request Echo HTTP Server</title>\n"
+            " </head>\n"
+            " <body>\n"
+            "  <h1>Print the HTTP request detail</h1>\n"
+            "  <ul>\n");
+
+  StrAppend(&response, "HTTP Method: ", req->http_method(), " <br>\n");
+  StrAppend(&response, "Request Uri: ", req->uri_path(), " <br>\n");
+
+  StrAppend(&response, "<br><br>====<br><br>\n");
+  for (auto header : req->request_headers()) {
+    StrAppend(&response, header, ": ", req->GetRequestHeader(header), "<br>\n");
+  }
+
+  // read the request body
+  int64_t num_bytes;
+  auto request_chunk = req->ReadRequestBytes(&num_bytes);
+  bool print_break = false;
+  while (request_chunk != nullptr) {
+    if (!print_break) {
+      StrAppend(&response, "<br><br>====<br><br>\n");
+      print_break = true;
+    }
+    StrAppend(&response, absl::string_view(request_chunk.get(),
+                                           static_cast<size_t>(num_bytes)));
+    request_chunk = req->ReadRequestBytes(&num_bytes);
+  }
+
+  req->WriteResponseString(response);
+
+  SetContentTypeHTML(req);
+  req->Reply();
+}
+
+// An executor that runs the current thread, testing only
+class MyExcecutor final : public EventExecutor {
+ public:
+  MyExcecutor() = default;
+
+  void Schedule(std::function<void()> fn) override { fn(); }
+};
+
+// Returns the server if success, or nullptr if there is any error.
+std::unique_ptr<HTTPServerInterface> StartServer(int port) {
+  auto options = absl::make_unique<ServerOptions>();
+  options->AddPort(port);
+  options->SetExecutor(absl::make_unique<MyExcecutor>());
+
+  auto server = CreateEvHTTPServer(std::move(options));
+
+  if (server == nullptr) {
+    return nullptr;
+  }
+
+  RequestHandlerOptions handler_options;
+  server->RegisterRequestHandler("/print", EchoHandler, handler_options);
+
+  // Blocking here with the use of MyExecutor
+  bool success = server->StartAcceptingRequests();
+
+  if (success) {
+    return server;
+  }
+
+  return nullptr;
+}
+
+}  // namespace
+
+int main(int argc, char** argv) {
+  if (argc < 2) {
+    std::cerr << "Usage: http-server <port:8080>" << std::endl;
+    return 1;
+  }
+
+  int port = 8080;
+  bool port_parsed = absl::SimpleAtoi(argv[1], &port);
+  if (!port_parsed) {
+    std::cerr << "Invalid port: " << argv[1] << std::endl;
+  }
+
+  auto server = StartServer(port);
+
+  if (server != nullptr) {
+    server->WaitForTermination();
+    return 0;
+  } else {
+    std::cerr << "Failed to start the server." << std::endl;
+    return 1;
+  }
+}
diff --git a/tensorflow_serving/util/net_http/socket/testing/BUILD b/tensorflow_serving/util/net_http/socket/testing/BUILD
new file mode 100644
index 00000000000..b71754fbbb4
--- /dev/null
+++ b/tensorflow_serving/util/net_http/socket/testing/BUILD
@@ -0,0 +1,27 @@
+# Description: net_http/socket testing utils
+
+package(
+    default_visibility = [
+        "//tensorflow_serving:internal",
+    ],
+    features = ["-layering_check"],
+)
+
+licenses(["notice"])  # Apache 2.0
+
+cc_binary(
+    name = "ev_print_req_server",
+    srcs = ["ev_print_req_server.cc"],
+    deps = [
+        "@com_github_libevent_libevent//:libevent",
+        "@com_google_absl//absl/strings",
+    ],
+)
+
+cc_binary(
+    name = "ev_fetch_client",
+    srcs = ["ev_fetch_client.cc"],
+    deps = [
+        "@com_github_libevent_libevent//:libevent",
+    ],
+)
diff --git a/tensorflow_serving/util/net_http/socket/testing/ev_fetch_client.cc b/tensorflow_serving/util/net_http/socket/testing/ev_fetch_client.cc
new file mode 100644
index 00000000000..4c39df75607
--- /dev/null
+++ b/tensorflow_serving/util/net_http/socket/testing/ev_fetch_client.cc
@@ -0,0 +1,194 @@
+/* Copyright 2018 Google Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#include <sys/types.h>
+
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+
+#include "libevent/include/event2/buffer.h"
+#include "libevent/include/event2/bufferevent.h"
+#include "libevent/include/event2/event.h"
+#include "libevent/include/event2/http.h"
+#include "libevent/include/event2/keyvalq_struct.h"
+#include "libevent/include/event2/util.h"
+
+namespace {
+
+struct event_base* ev_base;
+struct evhttp_uri* http_uri;
+struct evhttp_connection* evcon;
+
+void response_cb(struct evhttp_request* req, void* ctx) {
+  char buffer[1024];
+  int nread;
+
+  if (req == nullptr) {
+    int errcode = EVUTIL_SOCKET_ERROR();
+    fprintf(stderr, "socket error = %s (%d)\n",
+            evutil_socket_error_to_string(errcode), errcode);
+    return;
+  }
+
+  fprintf(stderr, "Response line: %d %s\n",
+          evhttp_request_get_response_code(req),
+          evhttp_request_get_response_code_line(req));
+
+  struct evkeyvalq* headers = evhttp_request_get_input_headers(req);
+  struct evkeyval* header;
+  for (header = headers->tqh_first; header; header = header->next.tqe_next) {
+    fprintf(stderr, "%s : %s\n", header->key, header->value);
+  }
+
+  while ((nread = evbuffer_remove(evhttp_request_get_input_buffer(req), buffer,
+                                  sizeof(buffer))) > 0) {
+    fwrite(buffer, static_cast<size_t>(nread), 1, stderr);
+  }
+}
+
+void help() { fputs("Usage: ev_fetch-client uri [body]\n", stderr); }
+
+void err(const char* msg) { fputs(msg, stderr); }
+
+void cleanup() {
+  if (evcon != nullptr) {
+    evhttp_connection_free(evcon);
+  }
+  if (http_uri != nullptr) {
+    evhttp_uri_free(http_uri);
+  }
+
+  event_base_free(ev_base);
+}
+
+}  // namespace
+
+int main(int argc, char** argv) {
+  fprintf(stdout, "Start the http client ...\n");
+
+  if (argc < 2 || argc > 3) {
+    help();
+    return 1;
+  }
+
+  const char* url = argv[1];
+
+  const char* body = nullptr;
+
+  if (argc == 3) {
+    body = argv[2];
+  }
+
+  http_uri = evhttp_uri_parse(url);
+  if (http_uri == nullptr) {
+    err("malformed url");
+    return 1;
+  }
+
+  const char* scheme = evhttp_uri_get_scheme(http_uri);
+  if (scheme == nullptr || strcasecmp(scheme, "http") != 0) {
+    err("url must be http");
+    return 1;
+  }
+
+  const char* host = evhttp_uri_get_host(http_uri);
+  if (host == nullptr) {
+    err("url must have a host");
+    return 1;
+  }
+
+  int port = evhttp_uri_get_port(http_uri);
+  if (port == -1) {
+    port = (strcasecmp(scheme, "http") == 0) ? 80 : 443;
+  }
+
+  const char* path = evhttp_uri_get_path(http_uri);
+  if (strlen(path) == 0) {
+    path = "/";
+  }
+
+  char uri[256];
+  const char* query = evhttp_uri_get_query(http_uri);
+  if (query == nullptr) {
+    snprintf(uri, sizeof(uri) - 1, "%s", path);
+  } else {
+    snprintf(uri, sizeof(uri) - 1, "%s?%s", path, query);
+  }
+  uri[sizeof(uri) - 1] = '\0';
+
+  // Create event base
+  ev_base = event_base_new();
+  if (ev_base == nullptr) {
+    perror("event_base_new()");
+    return 1;
+  }
+
+  //  struct bufferevent* bev =
+  //      bufferevent_socket_new(ev_base, -1, BEV_OPT_CLOSE_ON_FREE);
+  //
+  //  if (bev == nullptr) {
+  //    fprintf(stderr, "bufferevent_socket_new() failed\n");
+  //    return 1;
+  //  }
+
+  // blocking call (DNS resolution)
+  evcon = evhttp_connection_base_bufferevent_new(
+      ev_base, nullptr, nullptr, host, static_cast<uint16_t>(port));
+  if (evcon == nullptr) {
+    fprintf(stderr, "evhttp_connection_base_bufferevent_new() failed\n");
+    return 1;
+  }
+
+  int retries = 0;
+  evhttp_connection_set_retries(evcon, retries);
+
+  int timeout_in_secs = 5;
+  evhttp_connection_set_timeout(evcon, timeout_in_secs);
+
+  struct evhttp_request* req = evhttp_request_new(response_cb, evcon);
+  if (req == nullptr) {
+    fprintf(stderr, "evhttp_request_new() failed\n");
+    return 1;
+  }
+
+  struct evkeyvalq* output_headers = evhttp_request_get_output_headers(req);
+  evhttp_add_header(output_headers, "Host", host);
+  evhttp_add_header(output_headers, "Connection", "close");
+
+  if (body) {
+    struct evbuffer* output_buffer = evhttp_request_get_output_buffer(req);
+    size_t size = strlen(body);
+
+    evbuffer_add(output_buffer, body, size);
+
+    char length_header[8];
+    evutil_snprintf(length_header, sizeof(length_header) - 1, "%lu", size);
+    evhttp_add_header(output_headers, "Content-Length", length_header);
+  }
+
+  int r = evhttp_make_request(evcon, req,
+                              body ? EVHTTP_REQ_POST : EVHTTP_REQ_GET, uri);
+  if (r != 0) {
+    fprintf(stderr, "evhttp_make_request() failed\n");
+    return 1;
+  }
+
+  event_base_dispatch(ev_base);
+
+  cleanup();
+
+  return 0;
+}
diff --git a/tensorflow_serving/util/net_http/socket/testing/ev_print_req_server.cc b/tensorflow_serving/util/net_http/socket/testing/ev_print_req_server.cc
new file mode 100644
index 00000000000..c17bc2a1efa
--- /dev/null
+++ b/tensorflow_serving/util/net_http/socket/testing/ev_print_req_server.cc
@@ -0,0 +1,241 @@
+/* Copyright 2018 Google Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#include <dirent.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+
+#include "absl/strings/numbers.h"
+
+#include "libevent/include/event2/buffer.h"
+#include "libevent/include/event2/event.h"
+#include "libevent/include/event2/http.h"
+#include "libevent/include/event2/keyvalq_struct.h"
+#include "libevent/include/event2/util.h"
+
+namespace {
+
+char uri_root[512];
+
+void request_cb(struct evhttp_request *req, void *arg) {
+  const char *method;
+
+  switch (evhttp_request_get_command(req)) {
+    case EVHTTP_REQ_GET:
+      method = "GET";
+      break;
+    case EVHTTP_REQ_POST:
+      method = "POST";
+      break;
+    case EVHTTP_REQ_HEAD:
+      method = "HEAD";
+      break;
+    case EVHTTP_REQ_PUT:
+      method = "PUT";
+      break;
+    case EVHTTP_REQ_DELETE:
+      method = "DELETE";
+      break;
+    case EVHTTP_REQ_OPTIONS:
+      method = "OPTIONS";
+      break;
+    case EVHTTP_REQ_TRACE:
+      method = "TRACE";
+      break;
+    case EVHTTP_REQ_CONNECT:
+      method = "CONNECT";
+      break;
+    case EVHTTP_REQ_PATCH:
+      method = "PATCH";
+      break;
+    default:
+      method = "unknown";
+      break;
+  }
+
+  struct evbuffer *response_body = evbuffer_new();
+  if (response_body == nullptr) {
+    evhttp_send_error(req, HTTP_SERVUNAVAIL, nullptr);
+    return;
+  }
+
+  evbuffer_add_printf(response_body,
+                      "<!DOCTYPE html>\n"
+                      "<html>\n <head>\n"
+                      "  <meta charset='utf-8'>\n"
+                      "  <title>Mini libevent httpserver</title>\n"
+                      " </head>\n"
+                      " <body>\n"
+                      "  <h1>Print the HTTP request detail</h1>\n"
+                      "  <ul>\n");
+
+  evbuffer_add_printf(response_body, "HTTP Method: %s <br>\n", method);
+
+  const char *uri = evhttp_request_get_uri(req);  // no malloc
+  evbuffer_add_printf(response_body, "Request Uri: %s <br>\n", uri);
+
+  struct evhttp_uri *decoded_url = evhttp_uri_parse(uri);
+  if (decoded_url == nullptr) {
+    evhttp_send_error(req, HTTP_BADREQUEST, nullptr);
+    return;
+  }
+
+  evbuffer_add_printf(response_body, "Decoded Uri:<br>\n");
+
+  evbuffer_add_printf(response_body, "&nbsp;&nbsp;scheme : %s <br>\n",
+                      evhttp_uri_get_scheme(decoded_url));
+  evbuffer_add_printf(response_body, "&nbsp;&nbsp;host : %s <br>\n",
+                      evhttp_uri_get_host(decoded_url));
+  evbuffer_add_printf(response_body, "&nbsp;&nbsp;port : %d <br>\n",
+                      evhttp_uri_get_port(decoded_url));
+  evbuffer_add_printf(response_body, "&nbsp;&nbsp;path : %s <br>\n",
+                      evhttp_uri_get_path(decoded_url));
+  evbuffer_add_printf(response_body, "&nbsp;&nbsp;query : %s <br>\n",
+                      evhttp_uri_get_query(decoded_url));
+
+  const char *path = evhttp_uri_get_path(decoded_url);
+  if (path == nullptr) {
+    path = "/";
+  }
+
+  evbuffer_add_printf(response_body, "Uri path: %s <br>\n", path);
+
+  char *decoded_path = evhttp_uridecode(path, 1, nullptr);
+  if (decoded_path == nullptr) {
+    evhttp_send_error(req, HTTP_BADREQUEST, nullptr);
+    return;
+  }
+
+  evbuffer_add_printf(response_body, "Decoded path: %s <br>\n", decoded_path);
+
+  evbuffer_add_printf(response_body, "<br><br>====<br><br>\n");
+
+  struct evkeyvalq *headers = evhttp_request_get_input_headers(req);
+
+  struct evkeyval *header;
+  for (header = headers->tqh_first; header; header = header->next.tqe_next) {
+    evbuffer_add_printf(response_body, "%s : %s<br>\n", header->key,
+                        header->value);
+  }
+
+  struct evbuffer *request_body = evhttp_request_get_input_buffer(req);
+  if (request_body != nullptr) {
+    evbuffer_add_printf(response_body, "<br><br>====<br><br>\n");
+    int result = evbuffer_add_buffer_reference(response_body, request_body);
+    if (result < 0) {
+      evbuffer_add_printf(response_body, ">>> Failed to print the body<br>\n");
+    }
+  }
+
+  evhttp_add_header(evhttp_request_get_output_headers(req), "Content-Type",
+                    "text/html");
+
+  evhttp_send_reply(req, 200, "OK", response_body);
+
+  evhttp_uri_free(decoded_url);
+  free(decoded_path);
+  evbuffer_free(response_body);
+}
+
+void help() { fprintf(stdout, "Usage: ev_print_req_server <port:8080>\n"); }
+
+}  // namespace
+
+int main(int argc, char **argv) {
+  fprintf(stdout, "Start the http server ...\n");
+
+  struct event_base *base;
+  struct evhttp *http;
+  struct evhttp_bound_socket *handle;
+
+  ev_uint32_t port = 8080;
+
+  if (argc < 2) {
+    help();
+    return 1;
+  }
+
+  bool port_parsed = absl::SimpleAtoi(argv[1], &port);
+  if (!port_parsed) {
+    fprintf(stderr, "Invalid port: %s\n", argv[1]);
+  }
+
+  base = event_base_new();
+  if (!base) {
+    fprintf(stderr, "Couldn't create an event_base: exiting\n");
+    return 1;
+  }
+
+  http = evhttp_new(base);
+  if (!http) {
+    fprintf(stderr, "couldn't create evhttp. Exiting.\n");
+    return 1;
+  }
+
+  // catch all
+  evhttp_set_gencb(http, request_cb, NULL);
+
+  // nullptr will bind to ipv4, which will fail to accept
+  // requests from clients where getaddressinfo() defaults to AF_INET6
+  handle = evhttp_bind_socket_with_handle(http, "::0", (ev_uint16_t)port);
+  if (!handle) {
+    fprintf(stderr, "couldn't bind to port %d. Exiting.\n", (int)port);
+    return 1;
+  }
+
+  {
+    /* Extract and display the address we're listening on. */
+    struct sockaddr_storage ss = {};
+    evutil_socket_t fd;
+    ev_socklen_t socklen = sizeof(ss);
+    char addrbuf[128];
+    void *inaddr;
+    const char *addr;
+    int got_port = -1;
+    fd = evhttp_bound_socket_get_fd(handle);
+    memset(&ss, 0, sizeof(ss));
+    if (getsockname(fd, (struct sockaddr *)&ss, &socklen)) {
+      perror("getsockname() failed");
+      return 1;
+    }
+    if (ss.ss_family == AF_INET) {
+      got_port = ntohs(((struct sockaddr_in *)&ss)->sin_port);
+      inaddr = &((struct sockaddr_in *)&ss)->sin_addr;
+    } else if (ss.ss_family == AF_INET6) {
+      got_port = ntohs(((struct sockaddr_in6 *)&ss)->sin6_port);
+      inaddr = &((struct sockaddr_in6 *)&ss)->sin6_addr;
+    } else {
+      fprintf(stderr, "Weird address family %d\n", ss.ss_family);
+      return 1;
+    }
+    addr = evutil_inet_ntop(ss.ss_family, inaddr, addrbuf, sizeof(addrbuf));
+    if (addr) {
+      printf("Listening on %s:%d\n", addr, got_port);
+      evutil_snprintf(uri_root, sizeof(uri_root), "http://%s:%d", addr,
+                      got_port);
+    } else {
+      fprintf(stderr, "evutil_inet_ntop failed\n");
+      return 1;
+    }
+  }
+
+  event_base_dispatch(base);
+
+  return 0;
+}
diff --git a/tensorflow_serving/workspace.bzl b/tensorflow_serving/workspace.bzl
index 657649b1cd4..6af90cf3c24 100644
--- a/tensorflow_serving/workspace.bzl
+++ b/tensorflow_serving/workspace.bzl
@@ -36,3 +36,25 @@ def tf_serving_workspace():
       name = "cares",
       actual = "@grpc//third_party/nanopb:nanopb",
   )
+
+  # ===== RapidJSON (rapidjson.org) dependencies =====
+  native.new_http_archive(
+      name = "com_github_tencent_rapidjson",
+      urls = [
+          "https://github.com/Tencent/rapidjson/archive/v1.1.0.zip",
+      ],
+      sha256 = "8e00c38829d6785a2dfb951bb87c6974fa07dfe488aa5b25deec4b8bc0f6a3ab",
+      strip_prefix = "rapidjson-1.1.0",
+      build_file = "third_party/rapidjson.BUILD"
+  )
+
+  # ===== libevent (libevent.org) dependencies =====
+  native.new_http_archive(
+      name = "com_github_libevent_libevent",
+      urls = [
+          "https://github.com/libevent/libevent/archive/release-2.1.8-stable.zip"
+      ],
+      sha256 = "70158101eab7ed44fd9cc34e7f247b3cae91a8e4490745d9d6eb7edc184e4d96",
+      strip_prefix = "libevent-release-2.1.8-stable",
+      build_file = "third_party/libevent.BUILD"
+  )
diff --git a/third_party/libevent.BUILD b/third_party/libevent.BUILD
new file mode 100644
index 00000000000..33551a921f2
--- /dev/null
+++ b/third_party/libevent.BUILD
@@ -0,0 +1,83 @@
+# libevent (libevent.org) library.
+# from https://github.com/libevent/libevent
+
+package(
+    default_visibility = ["//visibility:public"],
+)
+
+licenses(["notice"])  # BSD
+
+exports_files(["LICENSE"])
+
+include_files = [
+    "libevent/include/evdns.h",
+    "libevent/include/event.h",
+    "libevent/include/evhttp.h",
+    "libevent/include/evrpc.h",
+    "libevent/include/evutil.h",
+    "libevent/include/event2/buffer.h",
+    "libevent/include/event2/bufferevent_struct.h",
+    "libevent/include/event2/event.h",
+    "libevent/include/event2/http_struct.h",
+    "libevent/include/event2/rpc_struct.h",
+    "libevent/include/event2/buffer_compat.h",
+    "libevent/include/event2/dns.h",
+    "libevent/include/event2/event_compat.h",
+    "libevent/include/event2/keyvalq_struct.h",
+    "libevent/include/event2/tag.h",
+    "libevent/include/event2/bufferevent.h",
+    "libevent/include/event2/dns_compat.h",
+    "libevent/include/event2/event_struct.h",
+    "libevent/include/event2/listener.h",
+    "libevent/include/event2/tag_compat.h",
+    "libevent/include/event2/bufferevent_compat.h",
+    "libevent/include/event2/dns_struct.h",
+    "libevent/include/event2/http.h",
+    "libevent/include/event2/rpc.h",
+    "libevent/include/event2/thread.h",
+    "libevent/include/event2/event-config.h",
+    "libevent/include/event2/http_compat.h",
+    "libevent/include/event2/rpc_compat.h",
+    "libevent/include/event2/util.h",
+    "libevent/include/event2/visibility.h",
+]
+
+lib_files = [
+    "libevent/lib/libevent.a",
+    "libevent/lib/libevent_core.a",
+    "libevent/lib/libevent_extra.a",
+    "libevent/lib/libevent_pthreads.a",
+]
+
+genrule(
+    name = "libevent-srcs",
+    outs = include_files + lib_files,
+    cmd = "\n".join([
+        "export INSTALL_DIR=$$(pwd)/$(@D)/libevent",
+        "export TMP_DIR=$$(mktemp -d -t libevent.XXXXX)",
+        "mkdir -p $$TMP_DIR",
+        "cp -R $$(pwd)/external/com_github_libevent_libevent/* $$TMP_DIR",
+        "cd $$TMP_DIR",
+        "./autogen.sh",
+        "./configure --prefix=$$INSTALL_DIR --enable-shared=no --disable-openssl",
+        "make install",
+        "rm -rf $$TMP_DIR",
+    ]),
+)
+
+cc_library(
+    name = "libevent",
+    srcs = [
+        "libevent/lib/libevent.a",
+        "libevent/lib/libevent_pthreads.a",
+    ],
+    hdrs = include_files,
+    linkopts = ["-lpthread"],
+    includes = ["libevent/include"],
+    linkstatic = 1,
+)
+
+filegroup(
+    name = "libevent-files",
+    srcs = include_files + lib_files,
+)
diff --git a/third_party/rapidjson.BUILD b/third_party/rapidjson.BUILD
new file mode 100644
index 00000000000..c6ffc3859f8
--- /dev/null
+++ b/third_party/rapidjson.BUILD
@@ -0,0 +1,14 @@
+# RapidJSON (rapidjson.org) library.
+# from https://github.com/Tencent/rapidjson
+
+package(
+    default_visibility = ["//visibility:public"],
+)
+
+licenses(["notice"])  # BSD/MIT.
+
+cc_library(
+    name = "rapidjson",
+    hdrs = glob(["include/rapidjson/**/*.h"]),
+    includes = ["include"],
+)