feat: add support for text-only content in MCP tools

Cursor removed support for MCP Resources in version 0.46.9+, breaking compatibility with Firebolt’s MCP server which relied heavily on resource embedding.

To restore functionality, introduced the `--disable-resources` CLI flag that allows `Docs` and `Connect` tools to return plain text responses instead of embedded resources.

Author: kop

cmd/firebolt-mcp-server/main.go

@@ -63,6 +63,13 @@ func main() {
 				Usage:    "SSE transport listen address (used only if transport is set to sse)",
 				Sources:  cli.EnvVars("FIREBOLT_MCP_TRANSPORT_SSE_LISTEN_ADDRESS"),
 			},
+			&cli.BoolFlag{
+				Name:     "disable-resources",
+				Category: "MCP Transport",
+				Value:    false,
+				Usage:    "Return text content instead of embedded resources (for clients that do not support resources)",
+				Sources:  cli.EnvVars("FIREBOLT_MCP_DISABLE_RESOURCES"),
+			},
 			&cli.StringFlag{
 				Name:     "client-id",
 				Category: "Firebolt Authentication",
@@ -123,6 +130,7 @@ func run(ctx context.Context, cmd *cli.Command) error {
 
 	// Initialize MCP server
 	docsProof := generateRandomSecret()
+	disableResources := cmd.Bool("disable-resources")
 	resourceDocs := resources.NewDocs(fireboltdocs.FS, docsProof)
 	resourceAccounts := resources.NewAccounts(discoveryClient)
 	resourceDatabases := resources.NewDatabases(dbPool)
@@ -133,8 +141,8 @@ func run(ctx context.Context, cmd *cli.Command) error {
 		cmd.String("transport"),
 		cmd.String("transport-sse-listen-address"),
 		[]server.Tool{
-			tools.NewConnect(resourceAccounts, resourceDatabases, resourceEngines, docsProof),
-			tools.NewDocs(resourceDocs),
+			tools.NewConnect(resourceAccounts, resourceDatabases, resourceEngines, docsProof, disableResources),
+			tools.NewDocs(resourceDocs, disableResources),
 			tools.NewQuery(dbPool),
 		},
 		[]server.Prompt{

pkg/tools/connect.go

@@ -44,6 +44,7 @@ type Connect struct {
 	databasesFetcher DatabaseResourcesFetcher // Fetches database resources
 	enginesFetcher   EngineResourcesFetcher   // Fetches engine resources
 	docsProof        string                   // Shared with the docs resources
+	disableResources bool                     // Return text content instead of embedded resources
 }
 
 // NewConnect creates a new instance of the Connect tool with the provided resource fetchers.
@@ -53,12 +54,14 @@ func NewConnect(
 	databasesFetcher DatabaseResourcesFetcher,
 	enginesFetcher EngineResourcesFetcher,
 	docsProof string,
+	disableResources bool,
 ) *Connect {
 	return &Connect{
 		accountsFetcher:  accountsFetcher,
 		databasesFetcher: databasesFetcher,
 		enginesFetcher:   enginesFetcher,
 		docsProof:        docsProof,
+		disableResources: disableResources,
 	}
 }
 
@@ -178,7 +181,7 @@ func (t *Connect) Handler(ctx context.Context, request mcp.CallToolRequest) (*mc
 	return &mcp.CallToolResult{
 		Result: mcp.Result{},
 		Content: itertools.Map(results, func(i mcp.ResourceContents) mcp.Content {
-			return mcp.NewEmbeddedResource(i)
+			return textOrResourceContent(t.disableResources, i)
 		}),
 		IsError: false,
 	}, nil

pkg/tools/connect_test.go

@@ -80,13 +80,13 @@ func createEngineResource(accountName, engineName string) mcp.ResourceContents {
 
 func TestNewConnect(t *testing.T) {
 	mock := &MockResourceFetcher{}
-	connectTool := tools.NewConnect(mock, mock, mock, validProof)
+	connectTool := tools.NewConnect(mock, mock, mock, validProof, false)
 	assert.NotNil(t, connectTool)
 }
 
 func TestConnect_Tool(t *testing.T) {
 	mock := &MockResourceFetcher{}
-	connectTool := tools.NewConnect(mock, mock, mock, validProof)
+	connectTool := tools.NewConnect(mock, mock, mock, validProof, false)
 
 	tool := connectTool.Tool()
 	assert.Equal(t, "firebolt_connect", tool.Name)
@@ -131,7 +131,7 @@ func TestConnect_Handler_Success(t *testing.T) {
 	}
 
 	// Create the tool
-	connectTool := tools.NewConnect(mock, mock, mock, validProof)
+	connectTool := tools.NewConnect(mock, mock, mock, validProof, false)
 
 	// Execute the handler
 	request := mcp.CallToolRequest{}
@@ -199,7 +199,7 @@ func TestConnect_Handler_AccountFetchFailure(t *testing.T) {
 		},
 	}
 
-	connectTool := tools.NewConnect(mock, mock, mock, validProof)
+	connectTool := tools.NewConnect(mock, mock, mock, validProof, false)
 	request := mcp.CallToolRequest{}
 	request.Params.Arguments = map[string]any{
 		"docs_proof": validProof,
@@ -225,7 +225,7 @@ func TestConnect_Handler_InvalidAccountResource(t *testing.T) {
 		},
 	}
 
-	connectTool := tools.NewConnect(mock, mock, mock, validProof)
+	connectTool := tools.NewConnect(mock, mock, mock, validProof, false)
 	request := mcp.CallToolRequest{}
 	request.Params.Arguments = map[string]any{
 		"docs_proof": validProof,
@@ -251,7 +251,7 @@ func TestConnect_Handler_InvalidAccountJSON(t *testing.T) {
 		},
 	}
 
-	connectTool := tools.NewConnect(mock, mock, mock, validProof)
+	connectTool := tools.NewConnect(mock, mock, mock, validProof, false)
 	request := mcp.CallToolRequest{}
 	request.Params.Arguments = map[string]any{
 		"docs_proof": validProof,
@@ -273,7 +273,7 @@ func TestConnect_Handler_DatabasesFetchFailure(t *testing.T) {
 		},
 	}
 
-	connectTool := tools.NewConnect(mock, mock, mock, validProof)
+	connectTool := tools.NewConnect(mock, mock, mock, validProof, false)
 	request := mcp.CallToolRequest{}
 	request.Params.Arguments = map[string]any{
 		"docs_proof": validProof,
@@ -298,7 +298,7 @@ func TestConnect_Handler_EnginesFetchFailure(t *testing.T) {
 		},
 	}
 
-	connectTool := tools.NewConnect(mock, mock, mock, validProof)
+	connectTool := tools.NewConnect(mock, mock, mock, validProof, false)
 	request := mcp.CallToolRequest{}
 	request.Params.Arguments = map[string]any{
 		"docs_proof": validProof,
@@ -309,3 +309,73 @@ func TestConnect_Handler_EnginesFetchFailure(t *testing.T) {
 	assert.Contains(t, err.Error(), "failed to discover engine resources")
 	assert.Nil(t, result)
 }
+
+func TestConnect_Handler_DisableResources(t *testing.T) {
+	// Create test data
+	accounts := []string{"account1"}
+	databases := map[string][]string{
+		"account1": {"db1"},
+	}
+	engines := map[string][]string{
+		"account1": {"engine1"},
+	}
+
+	// Create mock fetcher
+	mock := &MockResourceFetcher{
+		AccountsFunc: func(ctx context.Context, accountName string) ([]mcp.ResourceContents, error) {
+			var resources []mcp.ResourceContents
+			for _, acc := range accounts {
+				resources = append(resources, createAccountResource(acc))
+			}
+			return resources, nil
+		},
+		DatabasesFunc: func(ctx context.Context, accountName, databaseName string) ([]mcp.ResourceContents, error) {
+			var resources []mcp.ResourceContents
+			for _, db := range databases[accountName] {
+				resources = append(resources, createDatabaseResource(accountName, db))
+			}
+			return resources, nil
+		},
+		EnginesFunc: func(ctx context.Context, accountName, engineName string) ([]mcp.ResourceContents, error) {
+			var resources []mcp.ResourceContents
+			for _, eng := range engines[accountName] {
+				resources = append(resources, createEngineResource(accountName, eng))
+			}
+			return resources, nil
+		},
+	}
+
+	// Create the tool with disableResources set to true
+	connectTool := tools.NewConnect(mock, mock, mock, validProof, true)
+
+	// Execute the handler
+	request := mcp.CallToolRequest{}
+	request.Params.Arguments = map[string]any{
+		"docs_proof": validProof,
+	}
+	result, err := connectTool.Handler(t.Context(), request)
+
+	// Assertions
+	require.NoError(t, err)
+	require.NotNil(t, result)
+	assert.False(t, result.IsError)
+
+	// Calculate expected total resources
+	expectedCount := len(accounts) // accounts
+	for _, dbs := range databases {
+		expectedCount += len(dbs) // databases
+	}
+	for _, engs := range engines {
+		expectedCount += len(engs) // engines
+	}
+
+	// Check if we got the expected number of resources
+	assert.Len(t, result.Content, expectedCount)
+
+	// Verify the content contains text content instead of embedded resources
+	for _, content := range result.Content {
+		textContent, ok := content.(mcp.TextContent)
+		require.True(t, ok, "Expected TextContent when disableResources is true")
+		assert.NotEmpty(t, textContent.Text)
+	}
+}

pkg/tools/docs.go

@@ -21,14 +21,16 @@ type DocsResourcesFetcher interface {
 // Docs represents a tool for fetching and returning Firebolt documentation.
 // It provides access to documentation articles that explain Firebolt concepts and functionality.
 type Docs struct {
-	docsFetcher DocsResourcesFetcher // Fetches documentation resources
+	docsFetcher      DocsResourcesFetcher // Fetches documentation resources
+	disableResources bool                 // Return text content instead of embedded resources
 }
 
 // NewDocs creates a new instance of the Docs tool with the provided documentation fetcher.
 // It requires an implementation for fetching documentation articles.
-func NewDocs(docsFetcher DocsResourcesFetcher) *Docs {
+func NewDocs(docsFetcher DocsResourcesFetcher, disableResources bool) *Docs {
 	return &Docs{
-		docsFetcher: docsFetcher,
+		docsFetcher:      docsFetcher,
+		disableResources: disableResources,
 	}
 }
 
@@ -103,7 +105,7 @@ func (t *Docs) Handler(ctx context.Context, request mcp.CallToolRequest) (*mcp.C
 	return &mcp.CallToolResult{
 		Result: mcp.Result{},
 		Content: itertools.Map(results, func(i mcp.ResourceContents) mcp.Content {
-			return mcp.NewEmbeddedResource(i)
+			return textOrResourceContent(t.disableResources, i)
 		}),
 		IsError: false,
 	}, nil

pkg/tools/docs_test.go

@@ -16,13 +16,13 @@ import (
 
 func TestNewDocs(t *testing.T) {
 	mock := &MockDocsFetcher{}
-	docsTool := tools.NewDocs(mock)
+	docsTool := tools.NewDocs(mock, false)
 	assert.NotNil(t, docsTool)
 }
 
 func TestDocs_Tool(t *testing.T) {
 	mock := &MockDocsFetcher{}
-	docsTool := tools.NewDocs(mock)
+	docsTool := tools.NewDocs(mock, false)
 
 	tool := docsTool.Tool()
 	assert.Equal(t, "firebolt_docs", tool.Name)
@@ -49,7 +49,7 @@ func TestDocs_Handler_DefaultArticles(t *testing.T) {
 	}
 
 	// Create the tool
-	docsTool := tools.NewDocs(mock)
+	docsTool := tools.NewDocs(mock, false)
 
 	// Execute the handler with empty request (should return default articles)
 	request := mcp.CallToolRequest{}
@@ -103,7 +103,7 @@ func TestDocs_Handler_SpecificArticles(t *testing.T) {
 	}
 
 	// Create the tool
-	docsTool := tools.NewDocs(mock)
+	docsTool := tools.NewDocs(mock, false)
 
 	// Execute the handler with specific articles
 	request := mcp.CallToolRequest{}
@@ -149,7 +149,7 @@ func TestDocs_Handler_FetchError(t *testing.T) {
 	}
 
 	// Create the tool
-	docsTool := tools.NewDocs(mock)
+	docsTool := tools.NewDocs(mock, false)
 
 	// Execute the handler
 	request := mcp.CallToolRequest{}
@@ -165,7 +165,7 @@ func TestDocs_Handler_FetchError(t *testing.T) {
 func TestDocs_Handler_InvalidArticleID(t *testing.T) {
 	// Create the tool with any mock
 	mock := &MockDocsFetcher{}
-	docsTool := tools.NewDocs(mock)
+	docsTool := tools.NewDocs(mock, false)
 
 	// Execute the handler with an invalid article ID type
 	request := mcp.CallToolRequest{}
@@ -195,7 +195,7 @@ func TestDocs_Handler_MultipleFetchedResources(t *testing.T) {
 	}
 
 	// Create the tool
-	docsTool := tools.NewDocs(mock)
+	docsTool := tools.NewDocs(mock, false)
 
 	// Execute the handler
 	request := mcp.CallToolRequest{}
@@ -228,6 +228,63 @@ func TestDocs_Handler_MultipleFetchedResources(t *testing.T) {
 	assert.True(t, resourceMap["firebolt://docs/multi-resource-2"])
 }
 
+func TestDocs_Handler_DisableResources(t *testing.T) {
+	// Create test data for default articles
+	mockArticles := map[string]string{
+		resources.DocsArticleOverview:  "# Firebolt Overview\nThis is an overview of Firebolt.",
+		resources.DocsArticleProof:     "# Proof Document\nSecret proof: proof_value_123",
+		resources.DocsArticleReference: "# Reference\nThis is the reference documentation.",
+	}
+
+	// Create mock fetcher that returns the mock articles
+	mock := &MockDocsFetcher{
+		FetchDocsFunc: func(ctx context.Context, article string) ([]mcp.ResourceContents, error) {
+			content, exists := mockArticles[article]
+			if !exists {
+				return nil, errors.New("article not found")
+			}
+			return []mcp.ResourceContents{createDocResource(article, content)}, nil
+		},
+	}
+
+	// Create the tool with disableResources set to true
+	docsTool := tools.NewDocs(mock, true)
+
+	// Execute the handler with empty request (should return default articles)
+	request := mcp.CallToolRequest{}
+	request.Params.Arguments = map[string]any{}
+	result, err := docsTool.Handler(t.Context(), request)
+
+	// Assertions
+	require.NoError(t, err)
+	require.NotNil(t, result)
+	assert.False(t, result.IsError)
+
+	// Should return 3 default articles
+	assert.Len(t, result.Content, 3)
+
+	// Verify the content contains text content instead of embedded resources
+	textContents := make(map[string]string)
+	for _, content := range result.Content {
+		textContent, ok := content.(mcp.TextContent)
+		require.True(t, ok, "Expected TextContent when disableResources is true")
+		assert.NotEmpty(t, textContent.Text)
+
+		// Store the text content for verification
+		for articleID, expectedContent := range mockArticles {
+			if textContent.Text == expectedContent {
+				textContents[articleID] = textContent.Text
+			}
+		}
+	}
+
+	// Check if all default articles are present
+	for articleID, expectedContent := range mockArticles {
+		assert.Contains(t, textContents, articleID)
+		assert.Equal(t, expectedContent, textContents[articleID])
+	}
+}
+
 type MockDocsFetcher struct {
 	FetchDocsFunc func(ctx context.Context, article string) ([]mcp.ResourceContents, error)
 }

pkg/tools/tools.go

@@ -0,0 +1,16 @@
+package tools
+
+import "github.com/mark3labs/mcp-go/mcp"
+
+// textOrResourceContent returns a text content if disableResources is true, otherwise returns an embedded resource.
+func textOrResourceContent(disableResources bool, i mcp.ResourceContents) mcp.Content {
+
+	if disableResources {
+		textResource, ok := i.(mcp.TextResourceContents)
+		if ok {
+			return mcp.NewTextContent(textResource.Text)
+		}
+	}
+
+	return mcp.NewEmbeddedResource(i)
+}