From dc8642c928e35b76fd627cba2e754a50997480c9 Mon Sep 17 00:00:00 2001 From: mattthew Date: Thu, 22 May 2025 16:42:09 -0400 Subject: [PATCH 1/6] Use new func WithBasePath is deprecated --- dgraph/cmd/alpha/run.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dgraph/cmd/alpha/run.go b/dgraph/cmd/alpha/run.go index b15597b2041..2153afb0e71 100644 --- a/dgraph/cmd/alpha/run.go +++ b/dgraph/cmd/alpha/run.go @@ -484,7 +484,7 @@ func setupMcp(baseMux *http.ServeMux, connectionString, url string, readOnly boo } sse := server.NewSSEServer(s, - server.WithBasePath(url), + server.WithStaticBasePath(url), ) baseMux.HandleFunc(url, sse.ServeHTTP) baseMux.HandleFunc(url+"/", sse.ServeHTTP) From 31c9a3ae6511267e63fbc6b40ce01872ea102235 Mon Sep 17 00:00:00 2001 From: mattthew Date: Thu, 22 May 2025 16:42:49 -0400 Subject: [PATCH 2/6] Add CORS handler --- dgraph/cmd/alpha/run.go | 14 ++++++++++++-- 1 file changed, 12 insertions(+), 2 deletions(-) diff --git a/dgraph/cmd/alpha/run.go b/dgraph/cmd/alpha/run.go index 2153afb0e71..2d99908a721 100644 --- a/dgraph/cmd/alpha/run.go +++ b/dgraph/cmd/alpha/run.go @@ -486,8 +486,18 @@ func setupMcp(baseMux *http.ServeMux, connectionString, url string, readOnly boo sse := server.NewSSEServer(s, server.WithStaticBasePath(url), ) - baseMux.HandleFunc(url, sse.ServeHTTP) - baseMux.HandleFunc(url+"/", sse.ServeHTTP) + + corsHandler := func(w http.ResponseWriter, r *http.Request) { + x.AddCorsHeaders(w) + if r.Method == http.MethodOptions { + w.WriteHeader(http.StatusOK) + return + } + sse.ServeHTTP(w, r) + } + + baseMux.HandleFunc(url, corsHandler) + baseMux.HandleFunc(url+"/", corsHandler) return nil } From cb2ea31101a4f47fe62238f5b1a4507c137d57a6 Mon Sep 17 00:00:00 2001 From: mattthew Date: Thu, 22 May 2025 16:45:24 -0400 Subject: [PATCH 3/6] Update tool, resources and prompt names to follow snake_case convention; fix error handling --- dgraph/cmd/mcp/mcp_server.go | 48 ++++++++++++++++++------------------ 1 file changed, 24 insertions(+), 24 deletions(-) diff --git a/dgraph/cmd/mcp/mcp_server.go b/dgraph/cmd/mcp/mcp_server.go index b22f71c34cb..09e324b5169 100644 --- a/dgraph/cmd/mcp/mcp_server.go +++ b/dgraph/cmd/mcp/mcp_server.go @@ -60,7 +60,7 @@ func NewMCPServer(connectionString string, readOnly bool) (*server.MCPServer, er server.WithRecovery(), ) - schemaTool := mcp.NewTool("Get-Schema", + schemaTool := mcp.NewTool("get_schema", mcp.WithDescription("Get Dgraph DQL Schema from dgraph db"), mcp.WithToolAnnotation(mcp.ToolAnnotation{ ReadOnlyHint: &True, @@ -70,8 +70,8 @@ func NewMCPServer(connectionString string, readOnly bool) (*server.MCPServer, er }), ) - queryTool := mcp.NewTool("Run-Query", - mcp.WithDescription("Run Dgraph Query on dgraph db"), + queryTool := mcp.NewTool("run_query", + mcp.WithDescription("Run Dgraph DQL Query on dgraph db"), mcp.WithString("query", mcp.Required(), mcp.Description("The query to perform"), @@ -85,7 +85,7 @@ func NewMCPServer(connectionString string, readOnly bool) (*server.MCPServer, er ) if !readOnly { - alterSchemaTool := mcp.NewTool("Alter-Schema", + alterSchemaTool := mcp.NewTool("alter_schema", mcp.WithDescription("Alter Dgraph DQL Schema in dgraph db"), mcp.WithString("schema", mcp.Required(), @@ -102,22 +102,22 @@ func NewMCPServer(connectionString string, readOnly bool) (*server.MCPServer, er s.AddTool(alterSchemaTool, func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) { schema, ok := request.GetArguments()["schema"].(string) if !ok { - return nil, fmt.Errorf("schema must be present") + return mcp.NewToolResultError("Schema must be present"), nil } // Execute alter operation conn, err := getConn(connectionString) if err != nil { - return nil, fmt.Errorf("error opening connection with Dgraph Alpha: %v", err) + return mcp.NewToolResultErrorFromErr("Error opening connection with Dgraph Alpha", err), nil } if err = conn.SetSchema(ctx, dgo.RootNamespace, schema); err != nil { - return nil, fmt.Errorf("schema alteration failed: %v", err) + return mcp.NewToolResultErrorFromErr("Schema alteration failed", err), nil } return mcp.NewToolResultText("Schema updated successfully"), nil }) - mutationTool := mcp.NewTool("Run-Mutation", + mutationTool := mcp.NewTool("run_mutation", mcp.WithDescription("Run DQL Mutation on dgraph db"), mcp.WithString("mutation", mcp.Required(), @@ -134,7 +134,7 @@ func NewMCPServer(connectionString string, readOnly bool) (*server.MCPServer, er s.AddTool(mutationTool, func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) { conn, err := getConn(connectionString) if err != nil { - return nil, err + return mcp.NewToolResultErrorFromErr("Error opening connection with Dgraph Alpha", err), nil } txn := conn.NewTxn() defer func() { @@ -145,14 +145,14 @@ func NewMCPServer(connectionString string, readOnly bool) (*server.MCPServer, er }() mutation, ok := request.GetArguments()["mutation"].(string) if !ok { - return nil, fmt.Errorf("mutation must present") + return mcp.NewToolResultError("Mutation must be present"), nil } resp, err := txn.Mutate(ctx, &api.Mutation{ SetJson: []byte(mutation), CommitNow: true, }) if err != nil { - return mcp.NewToolResultError(err.Error()), nil + return mcp.NewToolResultErrorFromErr("Error running mutation", err), nil } return mcp.NewToolResultText(string(resp.GetJson())), nil }) @@ -161,7 +161,7 @@ func NewMCPServer(connectionString string, readOnly bool) (*server.MCPServer, er s.AddTool(queryTool, func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) { conn, err := getConn(connectionString) if err != nil { - return nil, err + return mcp.NewToolResultErrorFromErr("Error opening connection with Dgraph Alpha", err), nil } txn := conn.NewTxn() defer func() { @@ -173,7 +173,7 @@ func NewMCPServer(connectionString string, readOnly bool) (*server.MCPServer, er op := request.GetArguments()["query"].(string) resp, err := txn.Query(ctx, op) if err != nil { - return mcp.NewToolResultError(err.Error()), nil + return mcp.NewToolResultErrorFromErr("Error running query", err), nil } return mcp.NewToolResultText(string(resp.GetJson())), nil }) @@ -181,7 +181,7 @@ func NewMCPServer(connectionString string, readOnly bool) (*server.MCPServer, er s.AddTool(schemaTool, func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) { conn, err := getConn(connectionString) if err != nil { - return nil, err + return mcp.NewToolResultErrorFromErr("Error opening connection with Dgraph Alpha", err), nil } txn := conn.NewTxn() defer func() { @@ -192,15 +192,15 @@ func NewMCPServer(connectionString string, readOnly bool) (*server.MCPServer, er }() resp, err := txn.Query(ctx, "schema {}") if err != nil { - return mcp.NewToolResultError(err.Error()), nil + return mcp.NewToolResultErrorFromErr("Error running query", err), nil } return mcp.NewToolResultText(string(resp.GetJson())), nil }) schemaResource := mcp.NewResource( "dgraph://schema", - "Dgraph Schema", - mcp.WithResourceDescription("The current Dgraph schema"), + "dgraph_schema", + mcp.WithResourceDescription("The current Dgraph DQL schema"), mcp.WithMIMEType("text/plain"), ) @@ -208,11 +208,11 @@ func NewMCPServer(connectionString string, readOnly bool) (*server.MCPServer, er // Execute operation conn, err := getConn(connectionString) if err != nil { - return nil, err + return nil, fmt.Errorf("Error opening connection with Dgraph Alpha: %w", err) } resp, err := conn.NewTxn().Query(ctx, "schema {}") if err != nil { - return nil, fmt.Errorf("failed to get schema: %v", err) + return nil, fmt.Errorf("Error running query: %w", err) } return []mcp.ResourceContents{ @@ -224,7 +224,7 @@ func NewMCPServer(connectionString string, readOnly bool) (*server.MCPServer, er }, nil }) - commonQueriesTool := mcp.NewTool("Get-Common-Queries", + commonQueriesTool := mcp.NewTool("get_common_queries", mcp.WithDescription("Get common queries that you can run on the db. If you are seeing issues with your queries, you can check this tool once."), mcp.WithToolAnnotation(mcp.ToolAnnotation{ ReadOnlyHint: &True, @@ -257,8 +257,8 @@ func NewMCPServer(connectionString string, readOnly bool) (*server.MCPServer, er }) commonQueries := mcp.NewResource( - "dgraph://common-queries", - "Dgraph common queries", + "dgraph://common_queries", + "dgraph_common_queries", mcp.WithResourceDescription("The current Dgraph common queries that you can use to fix your queries"), mcp.WithMIMEType("text/plain"), ) @@ -322,11 +322,11 @@ func NewMCPServer(connectionString string, readOnly bool) (*server.MCPServer, er func addPrompt(s *server.MCPServer) { prompt := string(promptBytes) - s.AddPrompt(mcp.NewPrompt("Quick start prompt", + s.AddPrompt(mcp.NewPrompt("quick_start_prompt", mcp.WithPromptDescription("A quick Start prompt for new users and llms"), ), func(ctx context.Context, request mcp.GetPromptRequest) (*mcp.GetPromptResult, error) { return mcp.NewGetPromptResult( - "A quick start prompt", + "quick_start_prompt", []mcp.PromptMessage{ mcp.NewPromptMessage( mcp.RoleAssistant, From 5384a09515edfe41fe4cc48f7c6736c62e4feb62 Mon Sep 17 00:00:00 2001 From: mattthew Date: Fri, 23 May 2025 15:55:16 -0400 Subject: [PATCH 4/6] Make the MCP server more resilient to malformed arguments --- dgraph/cmd/mcp/mcp_server.go | 49 +++++++++++++++++++++++++++++------- 1 file changed, 40 insertions(+), 9 deletions(-) diff --git a/dgraph/cmd/mcp/mcp_server.go b/dgraph/cmd/mcp/mcp_server.go index 09e324b5169..ffc4c644307 100644 --- a/dgraph/cmd/mcp/mcp_server.go +++ b/dgraph/cmd/mcp/mcp_server.go @@ -100,11 +100,21 @@ func NewMCPServer(connectionString string, readOnly bool) (*server.MCPServer, er ) s.AddTool(alterSchemaTool, func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) { - schema, ok := request.GetArguments()["schema"].(string) - if !ok { + args := request.GetArguments() + if args == nil { return mcp.NewToolResultError("Schema must be present"), nil } + schemaArg, ok := args["schema"] + if !ok || schemaArg == nil { + return mcp.NewToolResultError("Schema must be present"), nil + } + + schema, ok := schemaArg.(string) + if !ok { + return mcp.NewToolResultError("Schema must be a string"), nil + } + // Execute alter operation conn, err := getConn(connectionString) if err != nil { @@ -143,10 +153,20 @@ func NewMCPServer(connectionString string, readOnly bool) (*server.MCPServer, er glog.Errorf("failed to discard transaction: %v", err) } }() - mutation, ok := request.GetArguments()["mutation"].(string) - if !ok { + args := request.GetArguments() + if args == nil { return mcp.NewToolResultError("Mutation must be present"), nil } + + mutationArg, ok := args["mutation"] + if !ok || mutationArg == nil { + return mcp.NewToolResultError("Mutation must be present"), nil + } + + mutation, ok := mutationArg.(string) + if !ok { + return mcp.NewToolResultError("Mutation must be a string"), nil + } resp, err := txn.Mutate(ctx, &api.Mutation{ SetJson: []byte(mutation), CommitNow: true, @@ -154,7 +174,7 @@ func NewMCPServer(connectionString string, readOnly bool) (*server.MCPServer, er if err != nil { return mcp.NewToolResultErrorFromErr("Error running mutation", err), nil } - return mcp.NewToolResultText(string(resp.GetJson())), nil + return mcp.NewToolResultText(fmt.Sprintf("Mutation completed, %d UIDs created", len(resp.Uids)/2)), nil }) } @@ -170,7 +190,18 @@ func NewMCPServer(connectionString string, readOnly bool) (*server.MCPServer, er glog.Errorf("failed to discard transaction: %v", err) } }() - op := request.GetArguments()["query"].(string) + args := request.GetArguments() + if args == nil { + return mcp.NewToolResultError("Query must be present"), nil + } + queryArg, ok := args["query"] + if !ok || queryArg == nil { + return mcp.NewToolResultError("Query must be present"), nil + } + op, ok := queryArg.(string) + if !ok { + return mcp.NewToolResultError("Query must be a string"), nil + } resp, err := txn.Query(ctx, op) if err != nil { return mcp.NewToolResultErrorFromErr("Error running query", err), nil @@ -208,11 +239,11 @@ func NewMCPServer(connectionString string, readOnly bool) (*server.MCPServer, er // Execute operation conn, err := getConn(connectionString) if err != nil { - return nil, fmt.Errorf("Error opening connection with Dgraph Alpha: %w", err) + return nil, fmt.Errorf("error opening connection with Dgraph Alpha: %w", err) } resp, err := conn.NewTxn().Query(ctx, "schema {}") if err != nil { - return nil, fmt.Errorf("Error running query: %w", err) + return nil, fmt.Errorf("error running query: %w", err) } return []mcp.ResourceContents{ @@ -266,7 +297,7 @@ func NewMCPServer(connectionString string, readOnly bool) (*server.MCPServer, er s.AddResource(commonQueries, func(ctx context.Context, request mcp.ReadResourceRequest) ([]mcp.ResourceContents, error) { return []mcp.ResourceContents{ mcp.TextResourceContents{ - URI: "dgraph://commmon-queries", + URI: "dgraph://commmon_queries", MIMEType: "text/plain", Text: ` { From bf44d7121d8af51bc6a3abae144a65f9aeaead1d Mon Sep 17 00:00:00 2001 From: mattthew Date: Fri, 23 May 2025 15:55:41 -0400 Subject: [PATCH 5/6] Add an integration test for the MCP SSE server --- dgraph/cmd/mcp/mcp_server_sse_test.go | 239 ++++++++++++++++++++++++++ 1 file changed, 239 insertions(+) create mode 100644 dgraph/cmd/mcp/mcp_server_sse_test.go diff --git a/dgraph/cmd/mcp/mcp_server_sse_test.go b/dgraph/cmd/mcp/mcp_server_sse_test.go new file mode 100644 index 00000000000..0456d86faff --- /dev/null +++ b/dgraph/cmd/mcp/mcp_server_sse_test.go @@ -0,0 +1,239 @@ +//go:build integration2 + +/* + * SPDX-FileCopyrightText: © Hypermode Inc. + * SPDX-License-Identifier: Apache-2.0 + */ + +package mcp + +import ( + "context" + "encoding/json" + "fmt" + "testing" + "time" + + "github.com/hypermodeinc/dgraph/v25/dgraphtest" + "github.com/mark3labs/mcp-go/client" + "github.com/mark3labs/mcp-go/mcp" + + "github.com/stretchr/testify/require" +) + +func TestMCPSSE(t *testing.T) { + conf := dgraphtest.NewClusterConfig().WithNumAlphas(1).WithNumZeros(1).WithReplicas(1).WithMCP() + c, err := dgraphtest.NewLocalCluster(conf) + require.NoError(t, err) + require.NoError(t, c.Start()) + + port, err := c.GetAlphaHttpPublicPort(0) + require.NoError(t, err) + serverURL := fmt.Sprintf("http://localhost:%s/mcp/sse", port) + mcpClient, err := client.NewSSEMCPClient(serverURL) + require.NoError(t, err, "Should create SSE MCP client") + + defer func() { + mcpClient.Close() + c.Cleanup(t.Failed()) + }() + + ctx := context.Background() + startCtx, startCancel := context.WithTimeout(ctx, 60*time.Second) + defer startCancel() + err = mcpClient.Start(startCtx) + require.NoError(t, err, "Should start SSE MCP client") + + initReq := mcp.InitializeRequest{} + initReq.Params.ProtocolVersion = mcp.LATEST_PROTOCOL_VERSION + initReq.Params.ClientInfo = mcp.Implementation{ + Name: "sse-test-client", + Version: "1.0.0", + } + initResult, err := mcpClient.Initialize(context.Background(), initReq) + require.NoError(t, err, "Failed to initialize client") + require.NotNil(t, initResult, "Should receive initialization result") + + callTool := func(toolName string, args map[string]interface{}) (string, error) { + toolRequest := mcp.CallToolRequest{} + toolRequest.Params.Name = toolName + toolRequest.Params.Arguments = args + ctx := context.Background() + result, err := mcpClient.CallTool(ctx, toolRequest) + if err != nil { + return "", fmt.Errorf("tool call failed: %w", err) + } + + if result == nil || len(result.Content) == 0 { + return "", fmt.Errorf("empty result from tool %s", toolName) + } + + if result.IsError { + return "", fmt.Errorf("tool error: %v", result.Content[0]) + } + if textContent, ok := result.Content[0].(mcp.TextContent); ok { + return textContent.Text, nil + } + + return fmt.Sprintf("%v", result.Content[0]), nil + } + + t.Run("ServerMetadata", func(t *testing.T) { + require.Equal(t, "Dgraph MCP Server", initResult.ServerInfo.Name) + require.NotEmpty(t, initResult.ServerInfo.Version) + }) + + t.Run("ListTools", func(t *testing.T) { + toolsRequest := mcp.ListToolsRequest{} + toolListResult, err := mcpClient.ListTools(ctx, toolsRequest) + require.NoError(t, err, "ListTools should not fail") + require.NotNil(t, toolListResult, "Should receive tool list result") + + expectedTools := []string{ + "get_schema", + "run_query", + "alter_schema", + "run_mutation", + "get_common_queries", + } + + foundTools := make(map[string]bool) + for _, tool := range toolListResult.Tools { + foundTools[tool.Name] = true + } + + for _, expected := range expectedTools { + require.True(t, foundTools[expected], "Expected tool %s to be available", expected) + } + }) + + t.Run("ListResources", func(t *testing.T) { + resourcesRequest := mcp.ListResourcesRequest{} + resourceListResult, err := mcpClient.ListResources(ctx, resourcesRequest) + require.NoError(t, err, "ListResources should not fail") + require.NotNil(t, resourceListResult, "Should receive resource list result") + expectedResources := []string{ + "dgraph://schema", + "dgraph://common_queries", + } + + foundResources := make(map[string]bool) + for _, resource := range resourceListResult.Resources { + foundResources[resource.URI] = true + } + + for _, expected := range expectedResources { + require.True(t, foundResources[expected], "Expected resource %s to be available", expected) + } + + for _, resource := range resourceListResult.Resources { + t.Run(resource.URI, func(t *testing.T) { + resourceRequest := mcp.ReadResourceRequest{} + resourceRequest.Params.URI = resource.URI + resourceResult, err := mcpClient.ReadResource(ctx, resourceRequest) + require.NoError(t, err, "ReadResource should not fail") + require.NotNil(t, resourceResult, "Should receive resource result") + require.NotEmpty(t, resourceResult.Contents, "Should receive resource contents") + }) + } + }) + + t.Run("ListPrompts", func(t *testing.T) { + promptsRequest := mcp.ListPromptsRequest{} + promptListResult, err := mcpClient.ListPrompts(ctx, promptsRequest) + require.NoError(t, err, "ListPrompts should not fail") + require.NotNil(t, promptListResult, "Should receive prompt list result") + expectedPrompts := []string{ + "quick_start_prompt", + } + foundPrompts := make(map[string]bool) + for _, prompt := range promptListResult.Prompts { + foundPrompts[prompt.Name] = true + } + + for _, expected := range expectedPrompts { + require.True(t, foundPrompts[expected], "Expected prompt %s to be available", expected) + } + + for _, prompt := range promptListResult.Prompts { + t.Run(prompt.Name, func(t *testing.T) { + promptRequest := mcp.GetPromptRequest{} + promptRequest.Params.Name = prompt.Name + promptResult, err := mcpClient.GetPrompt(ctx, promptRequest) + require.NoError(t, err, "GetPrompt should not fail") + require.NotNil(t, promptResult, "Should receive prompt result") + require.NotEmpty(t, promptResult.Messages, "Should receive prompts") + }) + } + }) + + t.Run("GetSchema", func(t *testing.T) { + resultText, err := callTool("get_schema", map[string]interface{}{}) + + require.NoError(t, err, "GetSchema should not fail") + require.NotEmpty(t, resultText, "Should receive schema") + }) + + t.Run("AlterSchema", func(t *testing.T) { + args := map[string]interface{}{ + "schema": "n: string @index(term) .", + } + resultText, err := callTool("alter_schema", args) + + require.NoError(t, err, "AlterSchema should not fail") + require.NotEmpty(t, resultText, "Should receive alter schema result") + }) + + t.Run("RunMutation", func(t *testing.T) { + args := map[string]interface{}{ + "mutation": `{ + "set": [ + { + "uid": "_:1", + "n": "Foo" + } + ] +}`, + } + resultText, err := callTool("run_mutation", args) + + require.NoError(t, err, "RunMutation should not fail") + require.Equal(t, "Mutation completed, 1 UIDs created", resultText, "Should receive run mutation result") + }) + + t.Run("RunQuery", func(t *testing.T) { + args := map[string]interface{}{ + "query": `{q(func: allofterms(n, "Foo")) { uid }}`, + } + resultText, err := callTool("run_query", args) + + require.NoError(t, err, "RunQuery should not fail") + require.NotEmpty(t, resultText, "Should receive run query result") + + var result map[string][]map[string]string + err = json.Unmarshal([]byte(resultText), &result) + require.NoError(t, err, "Should be able to parse JSON response") + + require.Contains(t, result, "q", "Response should contain 'q' field") + require.Len(t, result["q"], 1, "Should have exactly one result") + require.Contains(t, result["q"][0], "uid", "Result should have 'uid' field") + + uidValue := result["q"][0]["uid"] + require.Regexp(t, `^0x[0-9a-f]+$`, uidValue, "UID should be in the format 0x followed by hexadecimal digits") + }) + + t.Run("RunQueryWithEmptyArgs", func(t *testing.T) { + args := map[string]interface{}{} + _, err := callTool("run_query", args) + + require.Error(t, err, "RunQueryWithEmptyArgs should fail") + require.Contains(t, err.Error(), "Query must be present") + }) + + t.Run("RunGetCommonQueries", func(t *testing.T) { + resultText, err := callTool("get_common_queries", map[string]interface{}{}) + + require.NoError(t, err, "RunGetCommonQueries should not fail") + require.NotEmpty(t, resultText, "Should receive run get common queries result") + }) +} From dd83fca7a03861d16f74a870504d1c204143fae8 Mon Sep 17 00:00:00 2001 From: mattthew Date: Fri, 23 May 2025 15:55:59 -0400 Subject: [PATCH 6/6] Add an MCP flag option --- dgraphtest/config.go | 19 ++++++++++++++----- dgraphtest/dgraph.go | 4 ++++ 2 files changed, 18 insertions(+), 5 deletions(-) diff --git a/dgraphtest/config.go b/dgraphtest/config.go index aa207f278c4..b9b1c59d8eb 100644 --- a/dgraphtest/config.go +++ b/dgraphtest/config.go @@ -109,11 +109,7 @@ type ClusterConfig struct { snapShotAfterEntries uint64 snapshotAfterDuration time.Duration repoDir string -} - -func (cc ClusterConfig) WithGraphqlLambdaURL(url string) ClusterConfig { - cc.lambdaURL = url - return cc + mcp bool } // NewClusterConfig generates a default ClusterConfig @@ -133,6 +129,7 @@ func NewClusterConfig() ClusterConfig { uidLease: 50, portOffset: -1, customPlugins: false, + mcp: false, } } @@ -240,6 +237,18 @@ func (cc ClusterConfig) WithCustomPlugins() ClusterConfig { return cc } +// WithGraphqlLambdaURL sets the graphql lambda url for alpha +func (cc ClusterConfig) WithGraphqlLambdaURL(url string) ClusterConfig { + cc.lambdaURL = url + return cc +} + +// WithMcp sets the mcp flag for alpha +func (cc ClusterConfig) WithMCP() ClusterConfig { + cc.mcp = true + return cc +} + func (cc ClusterConfig) GetClusterVolume(volume string) string { return cc.volumes[volume] } diff --git a/dgraphtest/dgraph.go b/dgraphtest/dgraph.go index 2bcdbbd355b..42792d22ff0 100644 --- a/dgraphtest/dgraph.go +++ b/dgraphtest/dgraph.go @@ -287,6 +287,10 @@ func (a *alpha) cmd(c *LocalCluster) []string { c.conf.snapShotAfterEntries, c.conf.snapshotAfterDuration))) } + if c.conf.mcp { + acmd = append(acmd, "--mcp") + } + return acmd }