diff --git a/controller/schema/dgraph_schema_store.go b/controller/schema/dgraph_schema_store.go
index 0d345bb..4f434d7 100644
--- a/controller/schema/dgraph_schema_store.go
+++ b/controller/schema/dgraph_schema_store.go
@@ -2,6 +2,7 @@
 
 import (
 	"bytes"
+	"errors"
 	"fmt"
 	"io/ioutil"
 	"net/http"
@@ -9,44 +10,49 @@
 
 	"github.com/golang/glog"
 	"github.com/itaysk/regogo"
+	"github.com/vektah/gqlparser"
 	"github.com/vektah/gqlparser/ast"
-	"github.com/vektah/gqlparser/parser"
 )
 
 const jsonContentType = "application/json"
+const textContentType = "text/plain"
 
-const getSchemaQuery = `{ "query": "{ getGQLSchema() { schema } }" }`
+const getSchemaQuery = `{ "query": "{ getGQLSchema() { generatedSchema } }" }`
+const runQuery = `{ "query": "%s" }`
 
-const addSchemaQuery = `{
-  "query": "mutation { updateGQLSchema(input: {set: {schema: \"%s\"}}) { gqlSchema { id schema } } }" }`
-
-type DgraphSchemaStore struct {
-	dgraphAddress string
+type DgraphClient struct {
+	gqlAdddress   string
+	schemaAddress string
 	gqlSchema     string
-	schema        *ast.SchemaDocument
+	schema        *ast.Schema
 }
 
-func NewDgraphSchemaStore(dgraphAddress string) (SchemaStore, error) {
-	ret := &DgraphSchemaStore{dgraphAddress: dgraphAddress, gqlSchema: ""}
+func NewDgraphClient(gqlAddress, schemaAddress string) (GraphQLClient, error) {
+	ret := &DgraphClient{
+		gqlAdddress:   gqlAddress,
+		schemaAddress: schemaAddress,
+		gqlSchema:     ""}
 	if err := ret.fetchSchema(); err != nil {
 		return nil, err
 	}
 	return ret, nil
 }
 
-func (s *DgraphSchemaStore) Schema() *ast.SchemaDocument {
+func (s *DgraphClient) Schema() *ast.Schema {
 	return s.schema
 }
 
-func (s *DgraphSchemaStore) AddSchema(gqlSchema string) error {
+func (s *DgraphClient) AddSchema(gqlSchema string) error {
 	return s.SetSchema(s.gqlSchema + gqlSchema)
 }
 
-func (s *DgraphSchemaStore) SetSchema(gqlSchema string) error {
+func (s *DgraphClient) SetSchema(gqlSchema string) error {
 	glog.Info("Setting GraphQL schema:")
 	glog.Info(gqlSchema)
-	req := fmt.Sprintf(addSchemaQuery, strings.ReplaceAll(strings.ReplaceAll(gqlSchema, "\n", " "), "\t", " "))
-	resp, err := http.Post(s.dgraphAddress, jsonContentType, bytes.NewReader([]byte(req)))
+	resp, err := http.Post(
+		s.schemaAddress+"/schema",
+		textContentType,
+		bytes.NewReader([]byte(gqlSchema)))
 	if err != nil {
 		return err
 	}
@@ -60,9 +66,12 @@
 	return s.fetchSchema()
 }
 
-func (s *DgraphSchemaStore) fetchSchema() error {
+func (s *DgraphClient) fetchSchema() error {
 	glog.Infof("Getting GraphQL schema with query: %s", getSchemaQuery)
-	resp, err := http.Post(s.dgraphAddress, jsonContentType, bytes.NewReader([]byte(getSchemaQuery)))
+	resp, err := http.Post(
+		s.schemaAddress,
+		jsonContentType,
+		bytes.NewReader([]byte(getSchemaQuery)))
 	if err != nil {
 		return err
 	}
@@ -72,14 +81,56 @@
 		return err
 	}
 	glog.Infof("Result: %s", string(respBody))
-	gqlSchema, err := regogo.Get(string(respBody), "input.data.getGQLSchema.schema")
+	gqlSchema, err := regogo.Get(
+		string(respBody),
+		"input.data.getGQLSchema.generatedSchema")
 	if err != nil {
 		return err
 	}
-	schema, gqlErr := parser.ParseSchema(&ast.Source{Input: gqlSchema.String()})
+	schema, gqlErr := gqlparser.LoadSchema(&ast.Source{Input: gqlSchema.String()})
 	if gqlErr != nil {
 		return gqlErr
 	}
 	s.schema = schema
 	return nil
 }
+
+func (s *DgraphClient) RunQuery(query string) (string, error) {
+	_, gqlErr := gqlparser.LoadQuery(s.Schema(), query)
+	if gqlErr != nil {
+		return "", errors.New(gqlErr.Error())
+	}
+	glog.Infof("Running GraphQL query: %s", query)
+	queryJson := fmt.Sprintf(runQuery, sanitizeQuery(query))
+	resp, err := http.Post(
+		s.gqlAdddress,
+		jsonContentType,
+		bytes.NewReader([]byte(queryJson)))
+	if err != nil {
+		return "", err
+	}
+	respBody, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		return "", err
+	}
+	respStr := string(respBody)
+	glog.Infof("Result: %s", string(respStr))
+	// errStr, err := regogo.Get(respStr, "input.errors")
+	// if err == nil {
+	// 	return "", errors.New(errStr.JSON())
+	// }
+	data, err := regogo.Get(respStr, "input.data")
+	if err != nil {
+		return "", err
+	}
+	return data.JSON(), nil
+}
+
+func sanitizeSchema(schema string) string {
+	return strings.ReplaceAll(
+		strings.ReplaceAll(schema, "\n", " "), "\t", " ")
+}
+
+func sanitizeQuery(query string) string {
+	return strings.ReplaceAll(query, "\"", "\\\"")
+}