diff --git a/elasticsearch/pom.xml b/elasticsearch/pom.xml
index 04d75304468..0a8e77c0098 100644
--- a/elasticsearch/pom.xml
+++ b/elasticsearch/pom.xml
@@ -33,9 +33,13 @@
   <name>Zeppelin: Elasticsearch interpreter</name>
 
   <properties>
-    <elasticsearch.version>2.3.3</elasticsearch.version>
+    <exclude.src.elastic>**/Elasticsearch5Connector.java</exclude.src.elastic>
+    <exclude.test.elastic>**/Elasticsearch5InterpreterTest.java</exclude.test.elastic>
+    <elasticsearch.version>2.4.1</elasticsearch.version>
     <guava.version>18.0</guava.version>
     <json-flattener.version>0.1.6</json-flattener.version>
+    <maven.compiler.source>1.7</maven.compiler.source>
+    <maven.compiler.target>1.7</maven.compiler.target>
   </properties>
 
   <dependencies>
@@ -46,12 +50,6 @@
       <scope>provided</scope>
     </dependency>
 
-    <dependency>
-      <groupId>org.elasticsearch</groupId>
-      <artifactId>elasticsearch</artifactId>
-      <version>${elasticsearch.version}</version>
-    </dependency>
-
     <dependency>
       <groupId>com.google.guava</groupId>
       <artifactId>guava</artifactId>
@@ -63,7 +61,7 @@
       <artifactId>json-flattener</artifactId>
       <version>${json-flattener.version}</version>
     </dependency>
-    
+
     <dependency>
       <groupId>org.slf4j</groupId>
       <artifactId>slf4j-api</artifactId>
@@ -89,6 +87,34 @@
         </executions>
       </plugin>
 
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-compiler-plugin</artifactId>
+        <version>3.6.0</version>
+        <configuration>
+          <source>${maven.compiler.source}</source>
+          <target>${maven.compiler.target}</target>
+          <excludes>
+            <exclude>${exclude.src.elastic}</exclude>
+          </excludes>
+        </configuration>
+
+        <executions>
+          <execution>
+            <id>default-testCompile</id>
+            <phase>test-compile</phase>
+            <configuration>
+              <testExcludes>
+                <exclude>${exclude.test.elastic}</exclude>
+              </testExcludes>
+            </configuration>
+            <goals>
+              <goal>testCompile</goal>
+            </goals>
+          </execution>
+        </executions>
+      </plugin>
+
       <plugin>
         <artifactId>maven-dependency-plugin</artifactId>
         <version>2.8</version>
@@ -131,7 +157,63 @@
           </execution>
         </executions>
       </plugin>
+
     </plugins>
   </build>
 
+  <profiles>
+    <profile>
+      <id>elasticsearch-2</id>
+      <activation>
+        <activeByDefault>true</activeByDefault>
+      </activation>
+      <dependencies>
+        <dependency>
+          <groupId>org.elasticsearch</groupId>
+          <artifactId>elasticsearch</artifactId>
+          <version>${elasticsearch.version}</version>
+        </dependency>
+      </dependencies>
+    </profile>
+
+    <profile>
+      <id>elasticsearch-5</id>
+      <properties>
+        <exclude.src.elastic>**/Elasticsearch2Connector.java</exclude.src.elastic>
+        <exclude.test.elastic>**/Elasticsearch2InterpreterTest.java</exclude.test.elastic>
+        <elasticsearch.version>5.0.0</elasticsearch.version>
+        <log4j2.version>2.6.2</log4j2.version>
+        <maven.compiler.source>1.8</maven.compiler.source>
+        <maven.compiler.target>1.8</maven.compiler.target>
+      </properties>
+      <dependencies>
+
+        <dependency>
+          <groupId>org.elasticsearch.client</groupId>
+          <artifactId>transport</artifactId>
+          <version>${elasticsearch.version}</version>
+        </dependency>
+
+        <dependency>
+          <groupId>org.elasticsearch</groupId>
+          <artifactId>elasticsearch</artifactId>
+          <version>${elasticsearch.version}</version>
+        </dependency>
+
+        <dependency>
+          <groupId>org.apache.logging.log4j</groupId>
+          <artifactId>log4j-api</artifactId>
+          <version>${log4j2.version}</version>
+        </dependency>
+
+        <dependency>
+          <groupId>org.apache.logging.log4j</groupId>
+          <artifactId>log4j-core</artifactId>
+          <version>${log4j2.version}</version>
+        </dependency>
+
+      </dependencies>
+    </profile>
+  </profiles>
+
 </project>
diff --git a/elasticsearch/src/main/java/org/apache/zeppelin/elasticsearch/Elasticsearch2Connector.java b/elasticsearch/src/main/java/org/apache/zeppelin/elasticsearch/Elasticsearch2Connector.java
new file mode 100644
index 00000000000..b2f96eb4119
--- /dev/null
+++ b/elasticsearch/src/main/java/org/apache/zeppelin/elasticsearch/Elasticsearch2Connector.java
@@ -0,0 +1,129 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+
+package org.apache.zeppelin.elasticsearch;
+
+import com.google.gson.JsonParseException;
+import org.apache.commons.lang.StringUtils;
+import org.elasticsearch.action.delete.DeleteResponse;
+import org.elasticsearch.action.search.SearchAction;
+import org.elasticsearch.action.search.SearchRequestBuilder;
+import org.elasticsearch.action.search.SearchResponse;
+import org.elasticsearch.client.transport.TransportClient;
+import org.elasticsearch.common.settings.Settings;
+import org.elasticsearch.common.transport.InetSocketTransportAddress;
+import org.elasticsearch.index.query.QueryBuilders;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.IOException;
+import java.net.InetAddress;
+import java.util.*;
+
+
+/**
+ * Connector for Elasticsearch 2.x used in ElasticsearchInterpreter.
+ */
+public class Elasticsearch2Connector extends ElasticsearchConnector {
+
+  private static Logger logger = LoggerFactory.getLogger(ElasticsearchConnector.class);
+
+  protected Elasticsearch2Connector(String host, int port, String clusterName,
+                                 int resultSize) {
+    super(host, port, clusterName, resultSize);
+  }
+
+  @Override
+  public void connect(Properties props) {
+    logger.info("prop={}", props);
+
+    try {
+      final Settings settings = Settings.builder()
+          .put("cluster.name", clusterName)
+          .put(props)
+          .build();
+      client = TransportClient.builder().settings(settings).build()
+          .addTransportAddress(
+          new InetSocketTransportAddress(InetAddress.getByName(host), port));
+    } catch (IOException e) {
+      logger.error("Open connection with Elasticsearch", e);
+    }
+  }
+
+  @Override
+  public void release() {
+    if (client != null) {
+      client.close();
+    }
+  }
+
+  /**
+   * Execute a "delete" request.
+   *
+   * @param urlItems Items of the URL
+   * @return Result of the delete request, it contains the id of the deleted document
+   */
+  public String executeDeleteQuery(String[] urlItems) {
+    if (urlItems.length != 3
+        || StringUtils.isEmpty(urlItems[0])
+        || StringUtils.isEmpty(urlItems[1])
+        || StringUtils.isEmpty(urlItems[2])) {
+      throw new RuntimeException("Bad URL (it should be /index/type/id) : " + urlItems);
+    }
+
+    final DeleteResponse response = client
+        .prepareDelete(urlItems[0], urlItems[1], urlItems[2])
+        .get();
+
+    if (!response.isFound()) {
+      throw new RuntimeException("Document not found");
+    }
+
+    return response.getId();
+  }
+
+  @Override
+  protected SearchResponse searchData(String[] urlItems, String query, int size) {
+
+    final SearchRequestBuilder reqBuilder =
+        new SearchRequestBuilder(client, SearchAction.INSTANCE);
+    reqBuilder.setIndices();
+
+    if (urlItems.length >= 1) {
+      reqBuilder.setIndices(StringUtils.split(urlItems[0], ","));
+    }
+    if (urlItems.length > 1) {
+      reqBuilder.setTypes(StringUtils.split(urlItems[1], ","));
+    }
+
+    if (!StringUtils.isEmpty(query)) {
+      // The query can be either JSON-formatted, nor a Lucene query
+      // So, try to parse as a JSON => if there is an error, consider the query a Lucene one
+      try {
+        final Map source = gson.fromJson(query, Map.class);
+        reqBuilder.setExtraSource(source);
+      } catch (JsonParseException e) {
+        // This is not a JSON (or maybe not well formatted...)
+        reqBuilder.setQuery(QueryBuilders.queryStringQuery(query).analyzeWildcard(true));
+      }
+    }
+
+    reqBuilder.setSize(size);
+    final SearchResponse response = reqBuilder.get();
+    return response;
+  }
+}
diff --git a/elasticsearch/src/main/java/org/apache/zeppelin/elasticsearch/Elasticsearch5Connector.java b/elasticsearch/src/main/java/org/apache/zeppelin/elasticsearch/Elasticsearch5Connector.java
new file mode 100644
index 00000000000..76cf5c6cb7d
--- /dev/null
+++ b/elasticsearch/src/main/java/org/apache/zeppelin/elasticsearch/Elasticsearch5Connector.java
@@ -0,0 +1,176 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+
+package org.apache.zeppelin.elasticsearch;
+
+import com.google.gson.JsonParseException;
+import org.apache.commons.io.IOUtils;
+import org.apache.commons.lang.StringUtils;
+import org.elasticsearch.action.delete.DeleteResponse;
+import org.elasticsearch.action.search.SearchAction;
+import org.elasticsearch.action.search.SearchRequestBuilder;
+import org.elasticsearch.action.search.SearchResponse;
+import org.elasticsearch.common.settings.Settings;
+import org.elasticsearch.common.transport.InetSocketTransportAddress;
+import org.elasticsearch.index.query.QueryBuilders;
+import org.elasticsearch.rest.RestStatus;
+import org.elasticsearch.search.builder.SearchSourceBuilder;
+import org.elasticsearch.transport.client.PreBuiltTransportClient;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.IOException;
+import java.net.InetAddress;
+import java.util.Map;
+import java.util.Properties;
+
+
+/**
+ * Connector for Elasticsearch 5.x used in ElasticsearchInterpreter.
+ */
+public class Elasticsearch5Connector extends ElasticsearchConnector {
+
+  private static Logger logger = LoggerFactory.getLogger(ElasticsearchConnector.class);
+
+  protected Elasticsearch5Connector(String host, int port, String clusterName, int resultSize) {
+    super(host, port, clusterName, resultSize);
+  }
+
+  @Override
+  public void connect(Properties props) {
+    logger.info("prop={}", props);
+
+    try {
+      // Since 5.0, client doesn't allow invalid options ignored in the previous version.
+      // So, copy props and remove default so that user insert arbitrary valid options.
+      Properties filtered = new Properties();
+      filtered.putAll(props);
+      filtered.remove(ELASTICSEARCH_CLUSTER_NAME);
+      filtered.remove(ELASTICSEARCH_HOST);
+      filtered.remove(ELASTICSEARCH_PORT);
+      filtered.remove(ELASTICSEARCH_RESULT_SIZE);
+
+      final Settings settings = Settings.builder()
+          .put("cluster.name", clusterName)
+          .put(filtered)
+          .build();
+      client = new PreBuiltTransportClient(settings)
+          .addTransportAddress(
+              new InetSocketTransportAddress(InetAddress.getByName(host), port));
+    } catch (IOException e) {
+      logger.error("Open connection with Elasticsearch", e);
+    }
+  }
+
+  /**
+   * Execute a "count" request.
+   *
+   * @param urlItems Items of the URL
+   * @param query    May contains the JSON of the request
+   * @return Result of the count request, it contains the total hits
+   */
+  @Override
+  public String executeCountQuery(String[] urlItems, String query) {
+    if (urlItems.length > 2) {
+      throw new RuntimeException(
+          "Bad URL (it should be /index1,index2,.../type1,type2,...) " + urlItems);
+    }
+    SearchRequestBuilder reqBuilder = null;
+
+    if (urlItems.length >= 1) {
+      reqBuilder = client.prepareSearch(StringUtils.split(urlItems[0], ","));
+    } else {
+      reqBuilder = client.prepareSearch();
+    }
+
+    if (urlItems.length > 1) {
+      reqBuilder.setTypes(StringUtils.split(urlItems[1], ","));
+    }
+
+    reqBuilder.setSize(0);
+
+    if (!StringUtils.isEmpty(query)) {
+      reqBuilder.setQuery(QueryBuilders.wrapperQuery(query));
+    }
+
+    final SearchResponse response = reqBuilder.get();
+    return "" + response.getHits().getTotalHits();
+  }
+
+  @Override
+  public void release() {
+    IOUtils.closeQuietly(client);
+  }
+
+  /**
+   * Execute a "delete" request.
+   *
+   * @param urlItems Items of the URL
+   * @return Result of the delete request, it contains the id of the deleted document
+   */
+  public String executeDeleteQuery(String[] urlItems) {
+    if (urlItems.length != 3
+        || StringUtils.isEmpty(urlItems[0])
+        || StringUtils.isEmpty(urlItems[1])
+        || StringUtils.isEmpty(urlItems[2])) {
+      throw new RuntimeException("Bad URL (it should be /index/type/id) : " + urlItems);
+    }
+
+    final DeleteResponse response = client
+        .prepareDelete(urlItems[0], urlItems[1], urlItems[2])
+        .get();
+
+    if (RestStatus.NOT_FOUND == response.status()) {
+      throw new RuntimeException("Document not found");
+    }
+
+    return response.getId();
+  }
+
+  @Override
+  protected SearchResponse searchData(String[] urlItems, String query, int size) {
+    final SearchRequestBuilder reqBuilder =
+        new SearchRequestBuilder(client, SearchAction.INSTANCE);
+    reqBuilder.setIndices();
+
+    if (urlItems.length >= 1) {
+      reqBuilder.setIndices(StringUtils.split(urlItems[0], ","));
+    }
+    if (urlItems.length > 1) {
+      reqBuilder.setTypes(StringUtils.split(urlItems[1], ","));
+    }
+
+    if (!StringUtils.isEmpty(query)) {
+      // The query can be either JSON-formatted, nor a Lucene query
+      // So, try to parse as a JSON => if there is an error, consider the query a Lucene one
+      try {
+        final Map source = gson.fromJson(query, Map.class);
+        // 
+        SearchSourceBuilder sourceBuilder = SearchSourceBuilder.searchSource()
+            .query(QueryBuilders.wrapperQuery(query));
+        reqBuilder.setSource(sourceBuilder);
+      } catch (JsonParseException e) {
+        // This is not a JSON (or maybe not well formatted...)
+        reqBuilder.setQuery(QueryBuilders.queryStringQuery(query).analyzeWildcard(true));
+      }
+    }
+
+    reqBuilder.setSize(size);
+    final SearchResponse response = reqBuilder.get();
+    return response;
+  }
+}
diff --git a/elasticsearch/src/main/java/org/apache/zeppelin/elasticsearch/ElasticsearchConnector.java b/elasticsearch/src/main/java/org/apache/zeppelin/elasticsearch/ElasticsearchConnector.java
new file mode 100644
index 00000000000..8a08ae0a7b7
--- /dev/null
+++ b/elasticsearch/src/main/java/org/apache/zeppelin/elasticsearch/ElasticsearchConnector.java
@@ -0,0 +1,364 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+
+package org.apache.zeppelin.elasticsearch;
+
+
+import com.github.wnameless.json.flattener.JsonFlattener;
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import org.apache.commons.lang3.StringUtils;
+import org.apache.zeppelin.interpreter.InterpreterResult;
+import org.elasticsearch.action.get.GetResponse;
+import org.elasticsearch.action.index.IndexResponse;
+import org.elasticsearch.action.search.SearchResponse;
+import org.elasticsearch.client.Client;
+import org.elasticsearch.common.xcontent.XContentBuilder;
+import org.elasticsearch.common.xcontent.XContentFactory;
+import org.elasticsearch.common.xcontent.XContentHelper;
+import org.elasticsearch.search.SearchHit;
+import org.elasticsearch.search.SearchHitField;
+import org.elasticsearch.search.aggregations.Aggregation;
+import org.elasticsearch.search.aggregations.Aggregations;
+import org.elasticsearch.search.aggregations.InternalMultiBucketAggregation;
+import org.elasticsearch.search.aggregations.bucket.InternalSingleBucketAggregation;
+import org.elasticsearch.search.aggregations.bucket.MultiBucketsAggregation;
+import org.elasticsearch.search.aggregations.metrics.InternalMetricsAggregation;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.IOException;
+import java.lang.reflect.Constructor;
+import java.util.*;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * Interface for ElasticsearchConnector implementations.
+ */
+public abstract class ElasticsearchConnector {
+
+  private static Logger logger = LoggerFactory.getLogger(ElasticsearchConnector.class);
+  private static final Pattern FIELD_NAME_PATTERN = Pattern.compile("\\[\\\\\"(.+)\\\\\"\\](.*)");
+  private static final String HELP = "Elasticsearch interpreter:\n"
+      + "General format: <command> /<indices>/<types>/<id> <option> <JSON>\n"
+      + "  - indices: list of indices separated by commas (depends on the command)\n"
+      + "  - types: list of document types separated by commas (depends on the command)\n"
+      + "Commands:\n"
+      + "  - search /indices/types <query>\n"
+      + "    . indices and types can be omitted (at least, you have to provide '/')\n"
+      + "    . a query is either a JSON-formatted query, nor a lucene query\n"
+      + "  - size <value>\n"
+      + "    . defines the size of the output set (default value is in the config)\n"
+      + "    . if used, this command must be declared before a search command\n"
+      + "  - count /indices/types <query>\n"
+      + "    . same comments as for the search\n"
+      + "  - get /index/type/id\n"
+      + "  - delete /index/type/id\n"
+      + "  - index /ndex/type/id <json-formatted document>\n"
+      + "    . the id can be omitted, elasticsearch will generate one";
+
+  protected final Gson gson = new GsonBuilder().setPrettyPrinting().create();
+
+  public static final String ELASTICSEARCH_HOST = "elasticsearch.host";
+  public static final String ELASTICSEARCH_PORT = "elasticsearch.port";
+  public static final String ELASTICSEARCH_CLUSTER_NAME = "elasticsearch.cluster.name";
+  public static final String ELASTICSEARCH_RESULT_SIZE = "elasticsearch.output.size";
+
+  public static String getHelpString(String additionalMessage) {
+    final StringBuffer buffer = new StringBuffer();
+
+    if (additionalMessage != null) {
+      buffer.append(additionalMessage).append("\n");
+    }
+
+    buffer.append(HELP).append("\n");
+
+    return buffer.toString();
+  }
+
+  protected String host = "localhost";
+  protected int port = 9300;
+  protected String clusterName = "elasticsearch";
+  protected int resultSize = 10;
+  protected Client client;
+
+  public int getResultSize() {
+    return resultSize;
+  }
+
+  public static boolean isElasticSearchVersion2() {
+    try {
+      Class.forName("org.elasticsearch.node.NodeBuilder");
+      return true;
+    } catch (ClassNotFoundException e) {
+      return false;
+    }
+  }
+
+  public static ElasticsearchConnector create(Properties props) {
+    String host = props.getProperty(ELASTICSEARCH_HOST);
+    int port = Integer.parseInt(props.getProperty(ELASTICSEARCH_PORT));
+    String clusterName = props.getProperty(ELASTICSEARCH_CLUSTER_NAME);
+    int resultSize = 10;
+    try {
+      resultSize = Integer.parseInt(props.getProperty(ELASTICSEARCH_RESULT_SIZE));
+    } catch (NumberFormatException e) {
+      logger.error("Unable to parse " + ELASTICSEARCH_RESULT_SIZE + " : " +
+          props.get(ELASTICSEARCH_RESULT_SIZE), e);
+    }
+
+    Class<?> c = null;
+
+    String packagePrefix = "org.apache.zeppelin.elasticsearch.";
+
+    try {
+      if (isElasticSearchVersion2()) {
+        c = Class.forName(packagePrefix + "Elasticsearch2Connector");
+      } else {
+        // Assume that we are using 5.x
+        c = Class.forName(packagePrefix + "Elasticsearch5Connector");
+      }
+
+      // Use Integer.TYPE since we are using the primitive int
+      Constructor<?> t = c.getDeclaredConstructor(
+          String.class, Integer.TYPE, String.class, Integer.TYPE);
+      return (ElasticsearchConnector) t.newInstance(host, port, clusterName, resultSize);
+    } catch (ReflectiveOperationException e) {
+      throw new RuntimeException(
+          "Failed to create ElasticsearchConnector using reflection", e);
+    }
+  }
+
+  protected ElasticsearchConnector(String host, int port, String clusterName, int resultSize) {
+    this.host = host;
+    this.port = port;
+    this.clusterName = clusterName;
+    this.resultSize = resultSize;
+  }
+
+  protected abstract SearchResponse searchData(String[] urlItems, String query, int size);
+  public abstract void connect(Properties properties);
+  public abstract void release();
+  public abstract String executeDeleteQuery(String [] urlItems);
+
+  /**
+   * Execute a "get" request.
+   *
+   * @param urlItems Items of the URL
+   * @return Result of the get request, it contains a JSON-formatted string
+   */
+  public String executeGetQuery(String[] urlItems) {
+
+    if (urlItems.length != 3
+        || StringUtils.isEmpty(urlItems[0])
+        || StringUtils.isEmpty(urlItems[1])
+        || StringUtils.isEmpty(urlItems[2])) {
+      throw new RuntimeException("Bad URL (it should be /index/type/id):" + urlItems);
+    }
+
+    final GetResponse response = client
+        .prepareGet(urlItems[0], urlItems[1], urlItems[2])
+        .get();
+
+    if (!response.isExists()) {
+      throw new RuntimeException("Document not found");
+    }
+
+    return gson.toJson(response.getSource());
+  }
+
+  /**
+   * Execute a "index" request.
+   *
+   * @param urlItems Items of the URL
+   * @param data     JSON to be indexed
+   * @return Result of the index request, it contains the id of the document
+   */
+  public String executeIndexQuery (String[] urlItems, String data) {
+    if (urlItems.length < 2 || urlItems.length > 3) {
+      throw new RuntimeException(
+          "Bad URL (it should be /index/type or /index/type/id) " + urlItems);
+    }
+
+    final IndexResponse response = client
+        .prepareIndex(urlItems[0], urlItems[1], urlItems.length == 2 ? null : urlItems[2])
+        .setSource(data)
+        .get();
+
+    return response.getId();
+  }
+
+  /**
+   * Execute a "count" request.
+   *
+   * @param urlItems Items of the URL
+   * @param data    May contains the JSON of the request
+   * @return Result of the count request, it contains the total hits
+   */
+  public String executeCountQuery(String[] urlItems, String data) {
+    if (urlItems.length > 2) {
+      throw new RuntimeException(
+          "Bad URL (it should be /index1,index2,.../type1,type2,...) " + urlItems);
+    }
+    final SearchResponse response = searchData(urlItems, data, 0);
+
+    return "" + response.getHits().getTotalHits();
+  }
+
+  /**
+   * Execute a "search" request.
+   *
+   * @param urlItems Items of the URL
+   * @param data     May contains the JSON of the request
+   * @param size     Limit of output set
+   * @return Result of the search request with its type,
+   *         it contains a tab-formatted string of the matching hits
+   */
+  public TypedElasticConnectorResult executeSearchQuery(String[] urlItems, String data, int size) {
+
+    if (urlItems.length > 2) {
+      throw new RuntimeException(
+          "Bad URL (it should be /index1,index2,.../type1,type2,...) :" + urlItems);
+    }
+
+    final SearchResponse response = searchData(urlItems, data, size);
+    final Aggregations aggregations = response.getAggregations();
+
+    if (aggregations != null && aggregations.asList().size() > 0) {
+      return buildAggResponseMessage(aggregations);
+    }
+
+    return new TypedElasticConnectorResult(InterpreterResult.Type.TABLE,
+        buildSearchHitsResponseMessage(response.getHits().getHits()));
+  }
+
+  private TypedElasticConnectorResult buildAggResponseMessage(Aggregations aggregations) {
+    // Only the output of the first aggregation is returned
+    final Aggregation agg = aggregations.asList().get(0);
+    InterpreterResult.Type resType = InterpreterResult.Type.TEXT;
+    String resMsg = "";
+
+    if (agg instanceof InternalMetricsAggregation) {
+      resMsg = XContentHelper.toString((InternalMetricsAggregation) agg).toString();
+    } else if (agg instanceof InternalSingleBucketAggregation) {
+      resMsg = XContentHelper.toString((InternalSingleBucketAggregation) agg).toString();
+    } else {
+      if (agg instanceof InternalMultiBucketAggregation) {
+        final Set<String> headerKeys = new HashSet<String>();
+        final List<Map<String, Object>> buckets = new LinkedList<Map<String, Object>>();
+        final InternalMultiBucketAggregation multiBucketAgg = (InternalMultiBucketAggregation) agg;
+
+        for (MultiBucketsAggregation.Bucket bucket : multiBucketAgg.getBuckets()) {
+          try {
+            final XContentBuilder builder = XContentFactory.jsonBuilder();
+            bucket.toXContent(builder, null);
+            final Map<String, Object> bucketMap = JsonFlattener.flattenAsMap(builder.string());
+            headerKeys.addAll(bucketMap.keySet());
+            buckets.add(bucketMap);
+          } catch (IOException e) {
+            logger.error("Processing bucket: " + e.getMessage(), e);
+          }
+        }
+
+        final StringBuffer buffer = new StringBuffer();
+        final String[] keys = headerKeys.toArray(new String[0]);
+        for (String key : keys) {
+          buffer.append("\t").append(key);
+        }
+        buffer.deleteCharAt(0);
+
+        for (Map<String, Object> bucket : buckets) {
+          buffer.append("\n");
+
+          for (String key : keys) {
+            buffer.append(bucket.get(key)).append("\t");
+          }
+          buffer.deleteCharAt(buffer.length() - 1);
+        }
+
+        resType = InterpreterResult.Type.TABLE;
+        resMsg = buffer.toString();
+      }
+    }
+
+    return new TypedElasticConnectorResult(resType, resMsg);
+  }
+
+  private String buildSearchHitsResponseMessage(SearchHit[] hits) {
+    if (hits == null || hits.length == 0) {
+      return "";
+    }
+
+    // 1. Get all the keys in order to build an ordered list of the values for each hit
+    final Map<String, Object> hitFields = new HashMap<String, Object>();
+    final List<Map<String, Object>> flattenHits = new LinkedList<Map<String, Object>>();
+    final Set<String> keys = new TreeSet<String>();
+    for (SearchHit hit : hits) {
+      // Fields can be found either in _source, or in fields (it depends on the query)
+      String json = hit.getSourceAsString();
+      if (json == null) {
+        hitFields.clear();
+        for (SearchHitField hitField : hit.getFields().values()) {
+          hitFields.put(hitField.getName(), hitField.getValues());
+        }
+        json = gson.toJson(hitFields);
+      }
+
+      final Map<String, Object> flattenJsonMap = JsonFlattener.flattenAsMap(json);
+      final Map<String, Object> flattenMap = new HashMap<String, Object>();
+      for (Iterator<String> iter = flattenJsonMap.keySet().iterator(); iter.hasNext(); ) {
+        // Replace keys that match a format like that : [\"keyname\"][0]
+        final String fieldName = iter.next();
+        final Matcher fieldNameMatcher = FIELD_NAME_PATTERN.matcher(fieldName);
+        if (fieldNameMatcher.matches()) {
+          flattenMap.put(fieldNameMatcher.group(1) + fieldNameMatcher.group(2),
+              flattenJsonMap.get(fieldName));
+        } else {
+          flattenMap.put(fieldName, flattenJsonMap.get(fieldName));
+        }
+      }
+      flattenHits.add(flattenMap);
+
+      for (String key : flattenMap.keySet()) {
+        keys.add(key);
+      }
+    }
+
+    // 2. Build the header of the table
+    final StringBuffer buffer = new StringBuffer();
+    for (String key : keys) {
+      buffer.append(key).append('\t');
+    }
+    buffer.replace(buffer.lastIndexOf("\t"), buffer.lastIndexOf("\t") + 1, "\n");
+
+    // 3. Build the output by using the key set
+    for (Map<String, Object> hit : flattenHits) {
+      for (String key : keys) {
+        final Object val = hit.get(key);
+        if (val != null) {
+          buffer.append(val);
+        }
+        buffer.append('\t');
+      }
+      buffer.replace(buffer.lastIndexOf("\t"), buffer.lastIndexOf("\t") + 1, "\n");
+    }
+
+    return buffer.toString();
+  }
+
+}
diff --git a/elasticsearch/src/main/java/org/apache/zeppelin/elasticsearch/ElasticsearchInterpreter.java b/elasticsearch/src/main/java/org/apache/zeppelin/elasticsearch/ElasticsearchInterpreter.java
index 549b5f25efd..72d8633ac87 100644
--- a/elasticsearch/src/main/java/org/apache/zeppelin/elasticsearch/ElasticsearchInterpreter.java
+++ b/elasticsearch/src/main/java/org/apache/zeppelin/elasticsearch/ElasticsearchInterpreter.java
@@ -17,56 +17,21 @@
 
 package org.apache.zeppelin.elasticsearch;
 
-import java.io.IOException;
-import java.net.InetAddress;
 import java.util.ArrayList;
 import java.util.Arrays;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Iterator;
-import java.util.LinkedList;
 import java.util.List;
-import java.util.Map;
 import java.util.Properties;
-import java.util.Set;
-import java.util.TreeSet;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
 
 import org.apache.commons.lang.StringUtils;
 import org.apache.zeppelin.interpreter.Interpreter;
 import org.apache.zeppelin.interpreter.InterpreterContext;
 import org.apache.zeppelin.interpreter.InterpreterResult;
 import org.apache.zeppelin.interpreter.thrift.InterpreterCompletion;
-import org.elasticsearch.action.delete.DeleteResponse;
-import org.elasticsearch.action.get.GetResponse;
-import org.elasticsearch.action.index.IndexResponse;
-import org.elasticsearch.action.search.SearchAction;
-import org.elasticsearch.action.search.SearchRequestBuilder;
-import org.elasticsearch.action.search.SearchResponse;
-import org.elasticsearch.client.Client;
-import org.elasticsearch.client.transport.TransportClient;
-import org.elasticsearch.common.settings.Settings;
-import org.elasticsearch.common.transport.InetSocketTransportAddress;
-import org.elasticsearch.common.xcontent.XContentBuilder;
-import org.elasticsearch.common.xcontent.XContentFactory;
-import org.elasticsearch.common.xcontent.XContentHelper;
-import org.elasticsearch.index.query.QueryBuilders;
-import org.elasticsearch.search.SearchHit;
-import org.elasticsearch.search.SearchHitField;
-import org.elasticsearch.search.aggregations.Aggregation;
-import org.elasticsearch.search.aggregations.Aggregations;
-import org.elasticsearch.search.aggregations.InternalMultiBucketAggregation;
-import org.elasticsearch.search.aggregations.bucket.InternalSingleBucketAggregation;
-import org.elasticsearch.search.aggregations.bucket.MultiBucketsAggregation;
-import org.elasticsearch.search.aggregations.metrics.InternalMetricsAggregation;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import com.github.wnameless.json.flattener.JsonFlattener;
 import com.google.gson.Gson;
 import com.google.gson.GsonBuilder;
-import com.google.gson.JsonParseException;
 
 
 /**
@@ -76,77 +41,29 @@ public class ElasticsearchInterpreter extends Interpreter {
 
   private static Logger logger = LoggerFactory.getLogger(ElasticsearchInterpreter.class);
 
-  private static final String HELP = "Elasticsearch interpreter:\n"
-    + "General format: <command> /<indices>/<types>/<id> <option> <JSON>\n"
-    + "  - indices: list of indices separated by commas (depends on the command)\n"
-    + "  - types: list of document types separated by commas (depends on the command)\n"
-    + "Commands:\n"
-    + "  - search /indices/types <query>\n"
-    + "    . indices and types can be omitted (at least, you have to provide '/')\n"
-    + "    . a query is either a JSON-formatted query, nor a lucene query\n"
-    + "  - size <value>\n"
-    + "    . defines the size of the result set (default value is in the config)\n"
-    + "    . if used, this command must be declared before a search command\n"
-    + "  - count /indices/types <query>\n"
-    + "    . same comments as for the search\n"
-    + "  - get /index/type/id\n"
-    + "  - delete /index/type/id\n"
-    + "  - index /ndex/type/id <json-formatted document>\n"
-    + "    . the id can be omitted, elasticsearch will generate one";
 
   protected static final List<String> COMMANDS = Arrays.asList(
-    "count", "delete", "get", "help", "index", "search");
-
-  private static final Pattern FIELD_NAME_PATTERN = Pattern.compile("\\[\\\\\"(.+)\\\\\"\\](.*)");
-
-
-  public static final String ELASTICSEARCH_HOST = "elasticsearch.host";
-  public static final String ELASTICSEARCH_PORT = "elasticsearch.port";
-  public static final String ELASTICSEARCH_CLUSTER_NAME = "elasticsearch.cluster.name";
-  public static final String ELASTICSEARCH_RESULT_SIZE = "elasticsearch.result.size";
+      "count", "delete", "get", "help", "index", "search");
 
   private final Gson gson = new GsonBuilder().setPrettyPrinting().create();
-  private Client client;
-  private String host = "localhost";
-  private int port = 9300;
-  private String clusterName = "elasticsearch";
-  private int resultSize = 10;
+
+  private ElasticsearchConnector connector;
 
   public ElasticsearchInterpreter(Properties property) {
     super(property);
-    this.host = getProperty(ELASTICSEARCH_HOST);
-    this.port = Integer.parseInt(getProperty(ELASTICSEARCH_PORT));
-    this.clusterName = getProperty(ELASTICSEARCH_CLUSTER_NAME);
-    try {
-      this.resultSize = Integer.parseInt(getProperty(ELASTICSEARCH_RESULT_SIZE));
-    } catch (NumberFormatException e) {
-      this.resultSize = 10;
-      logger.error("Unable to parse " + ELASTICSEARCH_RESULT_SIZE + " : " +
-        property.get(ELASTICSEARCH_RESULT_SIZE), e);
-    }
+    // should be called after set parent's props
+    Properties merged = getProperty();
+    connector = ElasticsearchConnector.create(merged);
   }
 
   @Override
   public void open() {
-    try {
-      logger.info("prop={}", getProperty());
-      final Settings settings = Settings.settingsBuilder()
-        .put("cluster.name", clusterName)
-        .put(getProperty())
-        .build();
-      client = TransportClient.builder().settings(settings).build()
-        .addTransportAddress(new InetSocketTransportAddress(InetAddress.getByName(host), port));
-    }
-    catch (IOException e) {
-      logger.error("Open connection with Elasticsearch", e);
-    }
+    connector.connect(getProperty());
   }
 
   @Override
   public void close() {
-    if (client != null) {
-      client.close();
-    }
+    connector.release();
   }
 
   @Override
@@ -157,13 +74,13 @@ public InterpreterResult interpret(String cmd, InterpreterContext interpreterCon
       return new InterpreterResult(InterpreterResult.Code.SUCCESS);
     }
 
-    int currentResultSize = resultSize;
-
-    if (client == null) {
+    if (null == connector) {
       return new InterpreterResult(InterpreterResult.Code.ERROR,
-        "Problem with the Elasticsearch client, please check your configuration (host, port,...)");
+          "Problem with the Elasticsearch client, " +
+              "please check your configuration (host, port,...)");
     }
 
+    int currentResultSize = connector.getResultSize();
     String[] items = StringUtils.split(cmd.trim(), " ", 3);
 
     // Process some specific commands (help, size, ...)
@@ -178,15 +95,15 @@ public InterpreterResult interpret(String cmd, InterpreterContext interpreterCon
 
       if (lines.length < 2) {
         return processHelp(InterpreterResult.Code.ERROR,
-                           "Size cmd must be followed by a search");
+            "Size cmd must be followed by a search");
       }
 
       final String[] sizeLine = StringUtils.split(lines[0], " ", 2);
       if (sizeLine.length != 2) {
-        return processHelp(InterpreterResult.Code.ERROR, "Right format is : size <value>");
+        return processHelp(InterpreterResult.Code.ERROR,
+            "Right format is : size <value>");
       }
       currentResultSize = Integer.parseInt(sizeLine[1]);
-
       items = StringUtils.split(lines[1].trim(), " ", 3);
     }
 
@@ -196,31 +113,32 @@ public InterpreterResult interpret(String cmd, InterpreterContext interpreterCon
 
     final String method = items[0];
     final String url = items[1];
-    final String data = items.length > 2 ? items[2].trim() : null;
-
+    final String query = items.length > 2 ? items[2].trim() : null;
     final String[] urlItems = StringUtils.split(url.trim(), "/");
 
+    return handleElasticsearchCommands(method, urlItems, query, currentResultSize);
+  }
+
+  private InterpreterResult handleElasticsearchCommands(String method, String[] urlItems,
+                                                        String query, int currentResultSize) {
     try {
       if ("get".equalsIgnoreCase(method)) {
         return processGet(urlItems);
-      }
-      else if ("count".equalsIgnoreCase(method)) {
-        return processCount(urlItems, data);
-      }
-      else if ("search".equalsIgnoreCase(method)) {
-        return processSearch(urlItems, data, currentResultSize);
-      }
-      else if ("index".equalsIgnoreCase(method)) {
-        return processIndex(urlItems, data);
-      }
-      else if ("delete".equalsIgnoreCase(method)) {
+      } else if ("count".equalsIgnoreCase(method)) {
+        return processCount(urlItems, query);
+      } else if ("index".equalsIgnoreCase(method)) {
+        return processIndex(urlItems, query);
+      } else if ("delete".equalsIgnoreCase(method)) {
         return processDelete(urlItems);
+      } else if ("search".equalsIgnoreCase(method)) {
+        return processSearch(urlItems, query, currentResultSize);
       }
 
       return processHelp(InterpreterResult.Code.ERROR, "Unknown command");
-    }
-    catch (Exception e) {
-      return new InterpreterResult(InterpreterResult.Code.ERROR, "Error : " + e.getMessage());
+    } catch (Exception e) {
+      logger.error("Failed to interpret", e);
+      return new InterpreterResult(InterpreterResult.Code.ERROR,
+          "Error : " + e.getMessage());
     }
   }
 
@@ -241,7 +159,7 @@ public int getProgress(InterpreterContext interpreterContext) {
 
   @Override
   public List<InterpreterCompletion> completion(String s, int i) {
-    final List suggestions = new ArrayList<>();
+    final List suggestions = new ArrayList<InterpreterCompletion>();
 
     for (String cmd : COMMANDS) {
       if (cmd.toLowerCase().contains(s)) {
@@ -252,113 +170,55 @@ public List<InterpreterCompletion> completion(String s, int i) {
   }
 
   private InterpreterResult processHelp(InterpreterResult.Code code, String additionalMessage) {
-    final StringBuffer buffer = new StringBuffer();
-
-    if (additionalMessage != null) {
-      buffer.append(additionalMessage).append("\n");
-    }
-
-    buffer.append(HELP).append("\n");
-
-    return new InterpreterResult(code, InterpreterResult.Type.TEXT, buffer.toString());
+    String message = ElasticsearchConnector.getHelpString(additionalMessage);
+    return new InterpreterResult(code, InterpreterResult.Type.TEXT, message);
   }
 
-  /**
-   * Processes a "get" request.
-   *
-   * @param urlItems Items of the URL
-   * @return Result of the get request, it contains a JSON-formatted string
-   */
   private InterpreterResult processGet(String[] urlItems) {
-
-    if (urlItems.length != 3
-        || StringUtils.isEmpty(urlItems[0])
-        || StringUtils.isEmpty(urlItems[1])
-        || StringUtils.isEmpty(urlItems[2])) {
-      return new InterpreterResult(InterpreterResult.Code.ERROR,
-                                   "Bad URL (it should be /index/type/id)");
-    }
-
-    final GetResponse response = client
-      .prepareGet(urlItems[0], urlItems[1], urlItems[2])
-      .get();
-    if (response.isExists()) {
-      final String json = gson.toJson(response.getSource());
-
-      return new InterpreterResult(
-                    InterpreterResult.Code.SUCCESS,
-                    InterpreterResult.Type.TEXT,
-                    json);
-    }
-
-    return new InterpreterResult(InterpreterResult.Code.ERROR, "Document not found");
+    String result = connector.executeGetQuery(urlItems);
+    return new InterpreterResult(
+        InterpreterResult.Code.SUCCESS,
+        InterpreterResult.Type.TEXT,
+        result);
   }
 
-  /**
-   * Processes a "count" request.
-   *
-   * @param urlItems Items of the URL
-   * @param data May contains the JSON of the request
-   * @return Result of the count request, it contains the total hits
-   */
   private InterpreterResult processCount(String[] urlItems, String data) {
-
-    if (urlItems.length > 2) {
-      return new InterpreterResult(InterpreterResult.Code.ERROR,
-                                   "Bad URL (it should be /index1,index2,.../type1,type2,...)");
-    }
-
-    final SearchResponse response = searchData(urlItems, data, 0);
-
     return new InterpreterResult(
-      InterpreterResult.Code.SUCCESS,
-      InterpreterResult.Type.TEXT,
-      "" + response.getHits().getTotalHits());
+        InterpreterResult.Code.SUCCESS,
+        InterpreterResult.Type.TEXT,
+        connector.executeCountQuery(urlItems, data));
   }
 
   /**
    * Processes a "search" request.
    *
    * @param urlItems Items of the URL
-   * @param data May contains the JSON of the request
-   * @param size Limit of result set
+   * @param data     May contains the JSON of the request
+   * @param size     Limit of output set
    * @return Result of the search request, it contains a tab-formatted string of the matching hits
    */
   private InterpreterResult processSearch(String[] urlItems, String data, int size) {
+    TypedElasticConnectorResult result = connector
+        .executeSearchQuery(urlItems, data, size);
 
-    if (urlItems.length > 2) {
-      return new InterpreterResult(InterpreterResult.Code.ERROR,
-                                   "Bad URL (it should be /index1,index2,.../type1,type2,...)");
-    }
-
-    final SearchResponse response = searchData(urlItems, data, size);
-
-    return buildResponseMessage(response);
+    return new InterpreterResult(
+        InterpreterResult.Code.SUCCESS,
+        result.type,
+        result.output);
   }
 
   /**
    * Processes a "index" request.
    *
    * @param urlItems Items of the URL
-   * @param data JSON to be indexed
+   * @param data     JSON to be indexed
    * @return Result of the index request, it contains the id of the document
    */
   private InterpreterResult processIndex(String[] urlItems, String data) {
-
-    if (urlItems.length < 2 || urlItems.length > 3) {
-      return new InterpreterResult(InterpreterResult.Code.ERROR,
-                                   "Bad URL (it should be /index/type or /index/type/id)");
-    }
-
-    final IndexResponse response = client
-      .prepareIndex(urlItems[0], urlItems[1], urlItems.length == 2 ? null : urlItems[2])
-      .setSource(data)
-      .get();
-
     return new InterpreterResult(
-      InterpreterResult.Code.SUCCESS,
-      InterpreterResult.Type.TEXT,
-      response.getId());
+        InterpreterResult.Code.SUCCESS,
+        InterpreterResult.Type.TEXT,
+        connector.executeIndexQuery(urlItems, data));
   }
 
   /**
@@ -368,196 +228,9 @@ private InterpreterResult processIndex(String[] urlItems, String data) {
    * @return Result of the delete request, it contains the id of the deleted document
    */
   private InterpreterResult processDelete(String[] urlItems) {
-
-    if (urlItems.length != 3
-        || StringUtils.isEmpty(urlItems[0])
-        || StringUtils.isEmpty(urlItems[1])
-        || StringUtils.isEmpty(urlItems[2])) {
-      return new InterpreterResult(InterpreterResult.Code.ERROR,
-                                   "Bad URL (it should be /index/type/id)");
-    }
-
-    final DeleteResponse response = client
-      .prepareDelete(urlItems[0], urlItems[1], urlItems[2])
-      .get();
-
-    if (response.isFound()) {
-      return new InterpreterResult(
+    return new InterpreterResult(
         InterpreterResult.Code.SUCCESS,
         InterpreterResult.Type.TEXT,
-        response.getId());
-    }
-
-    return new InterpreterResult(InterpreterResult.Code.ERROR, "Document not found");
-  }
-
-  private SearchResponse searchData(String[] urlItems, String query, int size) {
-
-    final SearchRequestBuilder reqBuilder = new SearchRequestBuilder(
-      client, SearchAction.INSTANCE);
-    reqBuilder.setIndices();
-
-    if (urlItems.length >= 1) {
-      reqBuilder.setIndices(StringUtils.split(urlItems[0], ","));
-    }
-    if (urlItems.length > 1) {
-      reqBuilder.setTypes(StringUtils.split(urlItems[1], ","));
-    }
-
-    if (!StringUtils.isEmpty(query)) {
-      // The query can be either JSON-formatted, nor a Lucene query
-      // So, try to parse as a JSON => if there is an error, consider the query a Lucene one
-      try {
-        final Map source = gson.fromJson(query, Map.class);
-        reqBuilder.setExtraSource(source);
-      }
-      catch (JsonParseException e) {
-        // This is not a JSON (or maybe not well formatted...)
-        reqBuilder.setQuery(QueryBuilders.queryStringQuery(query).analyzeWildcard(true));
-      }
-    }
-
-    reqBuilder.setSize(size);
-
-    final SearchResponse response = reqBuilder.get();
-
-    return response;
-  }
-
-  private InterpreterResult buildAggResponseMessage(Aggregations aggregations) {
-
-    // Only the result of the first aggregation is returned
-    //
-    final Aggregation agg = aggregations.asList().get(0);
-    InterpreterResult.Type resType = InterpreterResult.Type.TEXT;
-    String resMsg = "";
-
-    if (agg instanceof InternalMetricsAggregation) {
-      resMsg = XContentHelper.toString((InternalMetricsAggregation) agg).toString();
-    }
-    else if (agg instanceof InternalSingleBucketAggregation) {
-      resMsg = XContentHelper.toString((InternalSingleBucketAggregation) agg).toString();
-    }
-    else if (agg instanceof InternalMultiBucketAggregation) {
-      final Set<String> headerKeys = new HashSet<>();
-      final List<Map<String, Object>> buckets = new LinkedList<>();
-      final InternalMultiBucketAggregation multiBucketAgg = (InternalMultiBucketAggregation) agg;
-      
-      for (MultiBucketsAggregation.Bucket bucket : multiBucketAgg.getBuckets()) {
-        try {
-          final XContentBuilder builder = XContentFactory.jsonBuilder();
-          bucket.toXContent(builder, null);
-          final Map<String, Object> bucketMap = JsonFlattener.flattenAsMap(builder.string());
-          headerKeys.addAll(bucketMap.keySet());
-          buckets.add(bucketMap);
-        }
-        catch (IOException e) {
-          logger.error("Processing bucket: " + e.getMessage(), e);
-        }
-      }
-            
-      final StringBuffer buffer = new StringBuffer();
-      final String[] keys = headerKeys.toArray(new String[0]);
-      for (String key: keys) {
-        buffer.append("\t" + key);
-      }
-      buffer.deleteCharAt(0);
-      
-      for (Map<String, Object> bucket : buckets) {
-        buffer.append("\n");
-        
-        for (String key: keys) {
-          buffer.append(bucket.get(key)).append("\t");
-        }
-        buffer.deleteCharAt(buffer.length() - 1);
-      }
-
-      resType = InterpreterResult.Type.TABLE;
-      resMsg = buffer.toString();
-    }
-
-    return new InterpreterResult(InterpreterResult.Code.SUCCESS, resType, resMsg);
-  }
-
-  private String buildSearchHitsResponseMessage(SearchHit[] hits) {
-
-    if (hits == null || hits.length == 0) {
-      return "";
-    }
-
-    //First : get all the keys in order to build an ordered list of the values for each hit
-    //
-    final Map<String, Object> hitFields = new HashMap<>();
-    final List<Map<String, Object>> flattenHits = new LinkedList<>();
-    final Set<String> keys = new TreeSet<>();
-    for (SearchHit hit : hits) {
-      // Fields can be found either in _source, or in fields (it depends on the query)
-      //
-      String json = hit.getSourceAsString();
-      if (json == null) {
-        hitFields.clear();
-        for (SearchHitField hitField : hit.getFields().values()) {
-          hitFields.put(hitField.getName(), hitField.getValues());
-        }
-        json = gson.toJson(hitFields);
-      }
-
-      final Map<String, Object> flattenJsonMap = JsonFlattener.flattenAsMap(json);
-      final Map<String, Object> flattenMap = new HashMap<>();
-      for (Iterator<String> iter = flattenJsonMap.keySet().iterator(); iter.hasNext(); ) {
-        // Replace keys that match a format like that : [\"keyname\"][0]
-        final String fieldName = iter.next();
-        final Matcher fieldNameMatcher = FIELD_NAME_PATTERN.matcher(fieldName);
-        if (fieldNameMatcher.matches()) {
-          flattenMap.put(fieldNameMatcher.group(1) + fieldNameMatcher.group(2),
-            flattenJsonMap.get(fieldName));
-        }
-        else {
-          flattenMap.put(fieldName, flattenJsonMap.get(fieldName));
-        }
-      }
-      flattenHits.add(flattenMap);
-
-      for (String key : flattenMap.keySet()) {
-        keys.add(key);
-      }
-    }
-
-    // Next : build the header of the table
-    //
-    final StringBuffer buffer = new StringBuffer();
-    for (String key : keys) {
-      buffer.append(key).append('\t');
-    }
-    buffer.replace(buffer.lastIndexOf("\t"), buffer.lastIndexOf("\t") + 1, "\n");
-
-    // Finally : build the result by using the key set
-    //
-    for (Map<String, Object> hit : flattenHits) {
-      for (String key : keys) {
-        final Object val = hit.get(key);
-        if (val != null) {
-          buffer.append(val);
-        }
-        buffer.append('\t');
-      }
-      buffer.replace(buffer.lastIndexOf("\t"), buffer.lastIndexOf("\t") + 1, "\n");
-    }
-
-    return buffer.toString();
-  }
-
-  private InterpreterResult buildResponseMessage(SearchResponse response) {
-
-    final Aggregations aggregations = response.getAggregations();
-
-    if (aggregations != null && aggregations.asList().size() > 0) {
-      return buildAggResponseMessage(aggregations);
-    }
-
-    return new InterpreterResult(
-      InterpreterResult.Code.SUCCESS,
-      InterpreterResult.Type.TABLE,
-      buildSearchHitsResponseMessage(response.getHits().getHits()));
+        connector.executeDeleteQuery(urlItems));
   }
 }
diff --git a/elasticsearch/src/main/java/org/apache/zeppelin/elasticsearch/TypedElasticConnectorResult.java b/elasticsearch/src/main/java/org/apache/zeppelin/elasticsearch/TypedElasticConnectorResult.java
new file mode 100644
index 00000000000..3dd1a17209f
--- /dev/null
+++ b/elasticsearch/src/main/java/org/apache/zeppelin/elasticsearch/TypedElasticConnectorResult.java
@@ -0,0 +1,33 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+
+package org.apache.zeppelin.elasticsearch;
+
+import org.apache.zeppelin.interpreter.InterpreterResult;
+
+/**
+ * Wrap elasticsearch 5.0
+ */
+public class TypedElasticConnectorResult {
+  InterpreterResult.Type type;
+  String output;
+
+  TypedElasticConnectorResult(InterpreterResult.Type type, String output) {
+    this.type = type;
+    this.output = output;
+  }
+}
diff --git a/elasticsearch/src/test/java/org/apache/zeppelin/elasticsearch/ElasticsearchInterpreterTest.java b/elasticsearch/src/test/java/org/apache/zeppelin/elasticsearch/Elasticsearch2InterpreterTest.java
similarity index 76%
rename from elasticsearch/src/test/java/org/apache/zeppelin/elasticsearch/ElasticsearchInterpreterTest.java
rename to elasticsearch/src/test/java/org/apache/zeppelin/elasticsearch/Elasticsearch2InterpreterTest.java
index e47a49e5f75..3cbab65acfa 100644
--- a/elasticsearch/src/test/java/org/apache/zeppelin/elasticsearch/ElasticsearchInterpreterTest.java
+++ b/elasticsearch/src/test/java/org/apache/zeppelin/elasticsearch/Elasticsearch2InterpreterTest.java
@@ -36,20 +36,19 @@
 import org.elasticsearch.client.Client;
 import org.elasticsearch.common.settings.Settings;
 import org.elasticsearch.node.Node;
-import org.elasticsearch.node.NodeBuilder;
 import org.junit.AfterClass;
 import org.junit.Assert;
 import org.junit.BeforeClass;
 import org.junit.Test;
 
-public class ElasticsearchInterpreterTest {
+public class Elasticsearch2InterpreterTest {
 
   private static Client elsClient;
   private static Node elsNode;
   private static ElasticsearchInterpreter interpreter;
 
-  private static final String[] METHODS = { "GET", "PUT", "DELETE", "POST" };
-  private static final int[] STATUS = { 200, 404, 500, 403 };
+  private static final String[] METHODS = {"GET", "PUT", "DELETE", "POST"};
+  private static final int[] STATUS = {200, 404, 500, 403};
 
   private static final String ELS_CLUSTER_NAME = "zeppelin-elasticsearch-interpreter-test";
   private static final String ELS_HOST = "localhost";
@@ -57,56 +56,55 @@ public class ElasticsearchInterpreterTest {
   private static final String ELS_HTTP_PORT = "10200";
   private static final String ELS_PATH = "/tmp/els";
 
-
   @BeforeClass
   public static void populate() throws IOException {
 
-    final Settings settings = Settings.settingsBuilder()
-      .put("cluster.name", ELS_CLUSTER_NAME)
-      .put("network.host", ELS_HOST)
-      .put("http.port", ELS_HTTP_PORT)
-      .put("transport.tcp.port", ELS_TRANSPORT_PORT)
-      .put("path.home", ELS_PATH)
-      .build();
+    final Settings settings = Settings.builder()
+        .put("cluster.name", ELS_CLUSTER_NAME)
+        .put("network.host", ELS_HOST)
+        .put("http.port", ELS_HTTP_PORT)
+        .put("transport.tcp.port", ELS_TRANSPORT_PORT)
+        .put("path.home", ELS_PATH)
+        .build();
 
-    elsNode = NodeBuilder.nodeBuilder().settings(settings).node();
+    elsNode = new Node(settings).start();
     elsClient = elsNode.client();
 
     elsClient.admin().indices().prepareCreate("logs")
-      .addMapping("http", jsonBuilder()
-        .startObject().startObject("http").startObject("properties")
-          .startObject("content_length")
+        .addMapping("http", jsonBuilder()
+            .startObject().startObject("http").startObject("properties")
+            .startObject("content_length")
             .field("type", "integer")
-          .endObject()
-        .endObject().endObject().endObject()).get();
+            .endObject()
+            .endObject().endObject().endObject()).get();
 
     for (int i = 0; i < 50; i++) {
       elsClient.prepareIndex("logs", "http", "" + i)
-        .setRefresh(true)
-        .setSource(jsonBuilder()
-          .startObject()
-            .field("date", new Date())
-            .startObject("request")
+          .setRefresh(true)
+          .setSource(jsonBuilder()
+              .startObject()
+              .field("date", new Date())
+              .startObject("request")
               .field("method", METHODS[RandomUtils.nextInt(METHODS.length)])
               .field("url", "/zeppelin/" + UUID.randomUUID().toString())
               .field("headers", Arrays.asList("Accept: *.*", "Host: apache.org"))
-            .endObject()
-            .field("status", STATUS[RandomUtils.nextInt(STATUS.length)])
-            .field("content_length", RandomUtils.nextInt(2000))
-          )
-        .get();
+              .endObject()
+              .field("status", STATUS[RandomUtils.nextInt(STATUS.length)])
+              .field("content_length", RandomUtils.nextInt(2000))
+              .endObject())
+          .get();
     }
 
     final Properties props = new Properties();
-    props.put(ElasticsearchInterpreter.ELASTICSEARCH_HOST, ELS_HOST);
-    props.put(ElasticsearchInterpreter.ELASTICSEARCH_PORT, ELS_TRANSPORT_PORT);
-    props.put(ElasticsearchInterpreter.ELASTICSEARCH_CLUSTER_NAME, ELS_CLUSTER_NAME);
+    props.put(ElasticsearchConnector.ELASTICSEARCH_HOST, ELS_HOST);
+    props.put(ElasticsearchConnector.ELASTICSEARCH_PORT, ELS_TRANSPORT_PORT);
+    props.put(ElasticsearchConnector.ELASTICSEARCH_CLUSTER_NAME, ELS_CLUSTER_NAME);
     interpreter = new ElasticsearchInterpreter(props);
     interpreter.open();
   }
 
   @AfterClass
-  public static void clean() {
+  public static void clean() throws IOException {
     if (interpreter != null) {
       interpreter.close();
     }
@@ -165,28 +163,28 @@ public void testAgg() {
 
     // Single-value metric
     InterpreterResult res = interpreter.interpret("search /logs { \"aggs\" : { \"distinct_status_count\" : " +
-            " { \"cardinality\" : { \"field\" : \"status\" } } } }", null);
+        " { \"cardinality\" : { \"field\" : \"status\" } } } }", null);
     assertEquals(Code.SUCCESS, res.code());
 
     // Multi-value metric
     res = interpreter.interpret("search /logs { \"aggs\" : { \"content_length_stats\" : " +
-            " { \"extended_stats\" : { \"field\" : \"content_length\" } } } }", null);
+        " { \"extended_stats\" : { \"field\" : \"content_length\" } } } }", null);
     assertEquals(Code.SUCCESS, res.code());
 
     // Single bucket
     res = interpreter.interpret("search /logs { \"aggs\" : { " +
-            " \"200_OK\" : { \"filter\" : { \"term\": { \"status\": \"200\" } }, " +
-            "   \"aggs\" : { \"avg_length\" : { \"avg\" : { \"field\" : \"content_length\" } } } } } }", null);
+        " \"200_OK\" : { \"filter\" : { \"term\": { \"status\": \"200\" } }, " +
+        "   \"aggs\" : { \"avg_length\" : { \"avg\" : { \"field\" : \"content_length\" } } } } } }", null);
     assertEquals(Code.SUCCESS, res.code());
 
     // Multi-buckets
     res = interpreter.interpret("search /logs { \"aggs\" : { \"status_count\" : " +
-            " { \"terms\" : { \"field\" : \"status\" } } } }", null);
+        " { \"terms\" : { \"field\" : \"status\" } } } }", null);
     assertEquals(Code.SUCCESS, res.code());
-    
+
     res = interpreter.interpret("search /logs { \"aggs\" : { " +
-            " \"length\" : { \"terms\": { \"field\": \"status\" }, " +
-            "   \"aggs\" : { \"sum_length\" : { \"sum\" : { \"field\" : \"content_length\" } }, \"sum_status\" : { \"sum\" : { \"field\" : \"status\" } } } } } }", null);
+        " \"length\" : { \"terms\": { \"field\": \"status\" }, " +
+        "   \"aggs\" : { \"sum_length\" : { \"sum\" : { \"field\" : \"content_length\" } }, \"sum_status\" : { \"sum\" : { \"field\" : \"status\" } } } } } }", null);
     assertEquals(Code.SUCCESS, res.code());
   }
 
diff --git a/elasticsearch/src/test/java/org/apache/zeppelin/elasticsearch/Elasticsearch5InterpreterTest.java b/elasticsearch/src/test/java/org/apache/zeppelin/elasticsearch/Elasticsearch5InterpreterTest.java
new file mode 100644
index 00000000000..b252ec43bb7
--- /dev/null
+++ b/elasticsearch/src/test/java/org/apache/zeppelin/elasticsearch/Elasticsearch5InterpreterTest.java
@@ -0,0 +1,262 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+
+package org.apache.zeppelin.elasticsearch;
+
+import org.apache.commons.lang.math.RandomUtils;
+import org.apache.zeppelin.interpreter.InterpreterResult;
+import org.apache.zeppelin.interpreter.InterpreterResult.Code;
+import org.apache.zeppelin.interpreter.thrift.InterpreterCompletion;
+import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest;
+import org.elasticsearch.action.support.WriteRequest;
+import org.elasticsearch.client.Client;
+import org.elasticsearch.common.settings.Settings;
+import org.elasticsearch.common.unit.TimeValue;
+import org.elasticsearch.common.xcontent.XContentBuilder;
+import org.elasticsearch.index.reindex.ReindexPlugin;
+import org.elasticsearch.node.Node;
+import org.elasticsearch.node.NodeValidationException;
+import org.elasticsearch.node.internal.InternalSettingsPreparer;
+import org.elasticsearch.percolator.PercolatorPlugin;
+import org.elasticsearch.plugins.Plugin;
+import org.elasticsearch.script.mustache.MustachePlugin;
+import org.elasticsearch.transport.Netty3Plugin;
+import org.elasticsearch.transport.Netty4Plugin;
+import org.junit.AfterClass;
+import org.junit.Assert;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import java.io.IOException;
+import java.util.*;
+
+import static org.elasticsearch.common.xcontent.XContentFactory.jsonBuilder;
+import static org.junit.Assert.assertEquals;
+
+public class Elasticsearch5InterpreterTest {
+
+  private static Client elsClient;
+  private static Node elsNode;
+  private static ElasticsearchInterpreter interpreter;
+
+  private static final String[] METHODS = {"GET", "PUT", "DELETE", "POST"};
+  private static final int[] STATUS = {200, 404, 500, 403};
+
+  private static final String ELS_CLUSTER_NAME = "zeppelin-elasticsearch-interpreter-test";
+  private static final String ELS_HOST = "localhost";
+  private static final String ELS_TRANSPORT_PORT = "10300";
+  private static final String ELS_HTTP_PORT = "10200";
+  private static final String ELS_PATH = "/tmp/els";
+
+  static class PluginNode extends Node {
+    public PluginNode(final Settings settings) {
+      super(InternalSettingsPreparer.prepareEnvironment(settings, null),
+              Collections.singletonList(Netty4Plugin.class));
+    }
+  }
+
+  @BeforeClass
+  public static void populate() throws IOException, NodeValidationException {
+
+    elsNode = new PluginNode(Settings.builder()
+        .put("cluster.name", ELS_CLUSTER_NAME)
+        .put("network.host", ELS_HOST)
+        .put("http.port", ELS_HTTP_PORT)
+        .put("transport.tcp.port", ELS_TRANSPORT_PORT)
+        .put("path.home", ELS_PATH)
+        .build()
+    ).start();
+
+    elsNode
+        .client()
+        .admin()
+        .cluster()
+        .prepareHealth().
+        setWaitForGreenStatus().get();
+
+    elsClient = elsNode.client();
+    XContentBuilder b1 = jsonBuilder()
+        .startObject().startObject("http").startObject("properties")
+        .startObject("content_length")
+        .field("type", "integer")
+        .endObject()
+        .endObject().endObject().endObject();
+    elsClient.admin().indices().prepareCreate("logs")
+        .addMapping("http", b1).get();
+
+    for (int i = 0; i < 50; i++) {
+      XContentBuilder b2 = jsonBuilder()
+          .startObject()
+          .field("date", new Date())
+          .startObject("request")
+          .field("method", METHODS[RandomUtils.nextInt(METHODS.length)])
+          .field("url", "/zeppelin/" + UUID.randomUUID().toString())
+          .field("headers", Arrays.asList("Accept: *.*", "Host: apache.org"))
+          .endObject()
+          .field("status", STATUS[RandomUtils.nextInt(STATUS.length)])
+          .field("content_length", RandomUtils.nextInt(2000))
+          .endObject();
+
+      elsClient.prepareIndex("logs", "http", "" + i)
+          .setRefreshPolicy(WriteRequest.RefreshPolicy.IMMEDIATE)
+          .setSource(b2)
+          .get();
+    }
+
+    final Properties props = new Properties();
+    props.put(ElasticsearchConnector.ELASTICSEARCH_HOST, ELS_HOST);
+    props.put(ElasticsearchConnector.ELASTICSEARCH_PORT, ELS_TRANSPORT_PORT);
+    props.put(ElasticsearchConnector.ELASTICSEARCH_CLUSTER_NAME, ELS_CLUSTER_NAME);
+    interpreter = new ElasticsearchInterpreter(props);
+    interpreter.open();
+  }
+
+  @AfterClass
+  public static void clean() throws IOException {
+    if (interpreter != null) {
+      interpreter.close();
+    }
+
+    if (elsClient != null) {
+      elsClient.admin().indices().delete(new DeleteIndexRequest("logs")).actionGet();
+      elsClient.close();
+    }
+
+    if (elsNode != null) {
+      elsNode.close();
+    }
+  }
+
+  @Test
+  public void testCount() {
+
+    InterpreterResult res = interpreter.interpret("count /unknown", null);
+    assertEquals(Code.ERROR, res.code());
+
+    res = interpreter.interpret("count /logs", null);
+    assertEquals("50", res.message());
+  }
+
+  @Test
+  public void testGet() {
+
+    InterpreterResult res = interpreter.interpret("get /logs/http/unknown", null);
+    assertEquals(Code.ERROR, res.code());
+
+    res = interpreter.interpret("get /logs/http/10", null);
+    assertEquals(Code.SUCCESS, res.code());
+  }
+
+  @Test
+  public void testSearch() {
+
+    InterpreterResult res = interpreter.interpret("size 10\nsearch /logs *", null);
+    assertEquals(Code.SUCCESS, res.code());
+
+    res = interpreter.interpret("search /logs {{{hello}}}", null);
+    assertEquals(Code.ERROR, res.code());
+
+    res = interpreter.interpret("search /logs { \"query\": { \"match\": { \"status\": 500 } } }", null);
+    assertEquals(Code.SUCCESS, res.code());
+
+    res = interpreter.interpret("search /logs status:404", null);
+    assertEquals(Code.SUCCESS, res.code());
+
+    res = interpreter.interpret("search /logs { \"fields\": [ \"date\", \"request.headers\" ], \"query\": { \"match\": { \"status\": 500 } } }", null);
+    assertEquals(Code.SUCCESS, res.code());
+  }
+
+  @Test
+  public void testAgg() {
+
+    // Single-value metric
+    InterpreterResult res = interpreter.interpret("search /logs { \"aggs\" : { \"distinct_status_count\" : " +
+        " { \"cardinality\" : { \"field\" : \"status\" } } } }", null);
+    assertEquals(Code.SUCCESS, res.code());
+
+    // Multi-value metric
+    res = interpreter.interpret("search /logs { \"aggs\" : { \"content_length_stats\" : " +
+        " { \"extended_stats\" : { \"field\" : \"content_length\" } } } }", null);
+    assertEquals(Code.SUCCESS, res.code());
+
+    // Single bucket
+    res = interpreter.interpret("search /logs { \"aggs\" : { " +
+        " \"200_OK\" : { \"filter\" : { \"term\": { \"status\": \"200\" } }, " +
+        "   \"aggs\" : { \"avg_length\" : { \"avg\" : { \"field\" : \"content_length\" } } } } } }", null);
+    assertEquals(Code.SUCCESS, res.code());
+
+    // Multi-buckets
+    res = interpreter.interpret("search /logs { \"aggs\" : { \"status_count\" : " +
+        " { \"terms\" : { \"field\" : \"status\" } } } }", null);
+    assertEquals(Code.SUCCESS, res.code());
+
+    res = interpreter.interpret("search /logs { \"aggs\" : { " +
+        " \"length\" : { \"terms\": { \"field\": \"status\" }, " +
+        "   \"aggs\" : { \"sum_length\" : { \"sum\" : { \"field\" : \"content_length\" } }, \"sum_status\" : { \"sum\" : { \"field\" : \"status\" } } } } } }", null);
+    assertEquals(Code.SUCCESS, res.code());
+  }
+
+  @Test
+  public void testIndex() {
+
+    InterpreterResult res = interpreter.interpret("index /logs { \"date\": \"" + new Date() + "\", \"method\": \"PUT\", \"status\": \"500\" }", null);
+    assertEquals(Code.ERROR, res.code());
+
+    res = interpreter.interpret("index /logs/http { \"date\": \"2015-12-06T14:54:23.368Z\", \"method\": \"PUT\", \"status\": \"500\" }", null);
+    assertEquals(Code.SUCCESS, res.code());
+  }
+
+  @Test
+  public void testDelete() {
+
+    InterpreterResult res = interpreter.interpret("delete /logs/http/unknown", null);
+    assertEquals(Code.ERROR, res.code());
+
+    res = interpreter.interpret("delete /logs/http/11", null);
+    assertEquals("11", res.message());
+  }
+
+  @Test
+  public void testMisc() {
+
+    InterpreterResult res = interpreter.interpret(null, null);
+    assertEquals(Code.SUCCESS, res.code());
+
+    res = interpreter.interpret("   \n \n ", null);
+    assertEquals(Code.SUCCESS, res.code());
+  }
+
+  @Test
+  public void testCompletion() {
+    List expectedResultOne = Arrays.asList(new InterpreterCompletion("count", "count"));
+    List expectedResultTwo = Arrays.asList(new InterpreterCompletion("help", "help"));
+
+    List<InterpreterCompletion> resultOne = interpreter.completion("co", 0);
+    List<InterpreterCompletion> resultTwo = interpreter.completion("he", 0);
+    List<InterpreterCompletion> resultAll = interpreter.completion("", 0);
+
+    Assert.assertEquals(expectedResultOne, resultOne);
+    Assert.assertEquals(expectedResultTwo, resultTwo);
+
+    List allCompletionList = new ArrayList<>();
+    for (InterpreterCompletion ic : resultAll) {
+      allCompletionList.add(ic.getName());
+    }
+    Assert.assertEquals(interpreter.COMMANDS, allCompletionList);
+  }
+
+}
diff --git a/zeppelin-distribution/src/bin_license/LICENSE b/zeppelin-distribution/src/bin_license/LICENSE
index 99853d77c62..fb6ebe6d864 100644
--- a/zeppelin-distribution/src/bin_license/LICENSE
+++ b/zeppelin-distribution/src/bin_license/LICENSE
@@ -91,7 +91,8 @@ The following components are provided under Apache License.
     (Apache 2.0) Lucene Spatial (org.apache.lucene:lucene-spatial:5.3.1 - http://lucene.apache.org/lucene-parent/lucene-spatial)
     (Apache 2.0) Lucene Spatial 3D (org.apache.lucene:lucene-spatial3d:5.3.1 - http://lucene.apache.org/lucene-parent/lucene-spatial3d)
     (Apache 2.0) Lucene Suggest (org.apache.lucene:lucene-suggest:5.3.1 - http://lucene.apache.org/lucene-parent/lucene-suggest)
-    (Apache 2.0) Elasticsearch: Core (org.elasticsearch:elasticsearch:2.1.0 - http://nexus.sonatype.org/oss-repository-hosting.html/parent/elasticsearch)
+    (Apache 2.0) Elasticsearch: Core (org.elasticsearch:elasticsearch:2.4.1 - http://nexus.sonatype.org/oss-repository-hosting.html/parent/elasticsearch)
+    (Apache 2.0) Elasticsearch: Core (org.elasticsearch:elasticsearch:5.0.0 - http://nexus.sonatype.org/oss-repository-hosting.html/parent/elasticsearch)
     (Apache 2.0) Joda convert (org.joda:joda-convert:1.2 - http://joda-convert.sourceforge.net)
     (Apache 2.0) Shiro Core (org.apache.shiro:shiro-core:1.2.3 - https://shiro.apache.org)
     (Apache 2.0) Shiro Web (org.apache.shiro:shiro-web:1.2.3 - https://shiro.apache.org)