feat: Add MongoDB delete Tools (#974)

Add MongoDB `delete` Tools:

- mongodb-delete-one
- mongodb-delete-many

---------

Co-authored-by: Author: Venkatesh Shanbhag <91714892+theshanbhag@users.noreply.github.com>
Co-authored-by: Author: Dennis Geurts <dennisg@dennisg.nl>

cmd/root.go

@@ -69,6 +69,8 @@ import (
 	_ "github.com/googleapis/genai-toolbox/internal/tools/looker/lookerquery"
 	_ "github.com/googleapis/genai-toolbox/internal/tools/looker/lookerquerysql"
 	_ "github.com/googleapis/genai-toolbox/internal/tools/looker/lookerrunlook"
+	_ "github.com/googleapis/genai-toolbox/internal/tools/mongodb/mongodbdeletemany"
+	_ "github.com/googleapis/genai-toolbox/internal/tools/mongodb/mongodbdeleteone"
 	_ "github.com/googleapis/genai-toolbox/internal/tools/mongodb/mongodbfind"
 	_ "github.com/googleapis/genai-toolbox/internal/tools/mongodb/mongodbfindone"
 	_ "github.com/googleapis/genai-toolbox/internal/tools/mongodb/mongodbupdatemany"

docs/en/resources/tools/mongodb/mongodb-delete-many.md

@@ -0,0 +1,53 @@
+---
+title: "mongodb-delete-many"
+type: docs
+weight: 1
+description: > 
+  A "mongodb-delete-many" tool deletes all documents from a MongoDB collection that match a filter.
+aliases:
+- /resources/tools/mongodb-delete-many
+---
+
+## About
+
+The `mongodb-delete-many` tool performs a **bulk destructive operation**, deleting **ALL** documents from a collection that match a specified filter.
+
+The tool returns the total count of documents that were deleted. If the filter does not match any documents (i.e., the deleted count is 0), the tool will return an error.
+
+This tool is compatible with the following source kind:
+
+* [`mongodb`](../../sources/mongodb.md)
+
+---
+
+## Example
+
+Here is an example that performs a cleanup task by deleting all products from the `inventory` collection that belong to a discontinued brand.
+
+```yaml
+tools:
+  retire_brand_products:
+    kind: mongodb-delete-many
+    source: my-mongo-source
+    description: Deletes all products from a specified discontinued brand.
+    database: ecommerce
+    collection: inventory
+    filterPayload: |
+        { "brand_name": {{json .brand_to_delete}} }
+    filterParams:
+      - name: brand_to_delete
+        type: string
+        description: The name of the discontinued brand whose products should be deleted.
+```
+
+## Reference
+
+| **field**     | **type** | **required** | **description**                                                                                                     |
+|:--------------|:---------|:-------------|:--------------------------------------------------------------------------------------------------------------------|
+| kind          | string   | true         | Must be `mongodb-delete-many`.                                                                                      |
+| source        | string   | true         | The name of the `mongodb` source to use.                                                                            |
+| description   | string   | true         | A description of the tool that is passed to the LLM.                                                                |
+| database      | string   | true         | The name of the MongoDB database containing the collection.                                                         |
+| collection    | string   | true         | The name of the MongoDB collection from which to delete documents.                                                  |
+| filterPayload | string   | true         | The MongoDB query filter document to select the documents for deletion. Uses `{{json .param_name}}` for templating. |
+| filterParams  | list     | true         | A list of parameter objects that define the variables used in the `filterPayload`.                                  |

docs/en/resources/tools/mongodb/mongodb-delete-one.md

@@ -0,0 +1,55 @@
+---
+title: "mongodb-delete-one"
+type: docs
+weight: 1
+description: > 
+  A "mongodb-delete-one" tool deletes a single document from a MongoDB collection.
+aliases:
+- /resources/tools/mongodb-delete-one
+---
+
+## About
+
+The `mongodb-delete-one` tool performs a destructive operation, deleting the **first single document** that matches a specified filter from a MongoDB collection.
+
+If the filter matches multiple documents, only the first one found by the database will be deleted. This tool is useful for removing specific entries, such as a user account or a single item from an inventory based on a unique ID.
+
+The tool returns the number of documents deleted, which will be either `1` if a document was found and deleted, or `0` if no matching document was found.
+
+This tool is compatible with the following source kind:
+
+* [`mongodb`](../../sources/mongodb.md)
+
+---
+
+## Example
+
+Here is an example that deletes a specific user account from the `users` collection by matching their unique email address. This is a permanent action.
+
+```yaml
+tools:
+  delete_user_account:
+    kind: mongodb-delete-one
+    source: my-mongo-source
+    description: Permanently deletes a user account by their email address.
+    database: user_data
+    collection: users
+    filterPayload: |
+        { "email": {{json .email_address}} }
+    filterParams:
+      - name: email_address
+        type: string
+        description: The email of the user account to delete.
+```
+
+## Reference
+
+| **field**     | **type** | **required** | **description**                                                                                                    |
+|:--------------|:---------|:-------------|:-------------------------------------------------------------------------------------------------------------------|
+| kind          | string   | true         | Must be `mongodb-delete-one`.                                                                                      |
+| source        | string   | true         | The name of the `mongodb` source to use.                                                                           |
+| description   | string   | true         | A description of the tool that is passed to the LLM.                                                               |
+| database      | string   | true         | The name of the MongoDB database containing the collection.                                                        |
+| collection    | string   | true         | The name of the MongoDB collection from which to delete a document.                                                |
+| filterPayload | string   | true         | The MongoDB query filter document to select the document for deletion. Uses `{{json .param_name}}` for templating. |
+| filterParams  | list     | true         | A list of parameter objects that define the variables used in the `filterPayload`.                                 |

internal/tools/mongodb/mongodbdeletemany/mongodbdeletemany.go

@@ -0,0 +1,179 @@
+// Copyright 2025 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+package mongodbdeletemany
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"slices"
+
+	"github.com/goccy/go-yaml"
+	mongosrc "github.com/googleapis/genai-toolbox/internal/sources/mongodb"
+	"go.mongodb.org/mongo-driver/bson"
+	"go.mongodb.org/mongo-driver/mongo"
+	"go.mongodb.org/mongo-driver/mongo/options"
+
+	"github.com/googleapis/genai-toolbox/internal/sources"
+	"github.com/googleapis/genai-toolbox/internal/tools"
+)
+
+const kind string = "mongodb-delete-many"
+
+func init() {
+	if !tools.Register(kind, newConfig) {
+		panic(fmt.Sprintf("tool kind %q already registered", kind))
+	}
+}
+
+func newConfig(ctx context.Context, name string, decoder *yaml.Decoder) (tools.ToolConfig, error) {
+	actual := Config{Name: name}
+	if err := decoder.DecodeContext(ctx, &actual); err != nil {
+		return nil, err
+	}
+	return actual, nil
+}
+
+type Config struct {
+	Name          string           `yaml:"name" validate:"required"`
+	Kind          string           `yaml:"kind" validate:"required"`
+	Source        string           `yaml:"source" validate:"required"`
+	AuthRequired  []string         `yaml:"authRequired" validate:"required"`
+	Description   string           `yaml:"description" validate:"required"`
+	Database      string           `yaml:"database" validate:"required"`
+	Collection    string           `yaml:"collection" validate:"required"`
+	FilterPayload string           `yaml:"filterPayload" validate:"required"`
+	FilterParams  tools.Parameters `yaml:"filterParams" validate:"required"`
+}
+
+// validate interface
+var _ tools.ToolConfig = Config{}
+
+func (cfg Config) ToolConfigKind() string {
+	return kind
+}
+
+func (cfg Config) Initialize(srcs map[string]sources.Source) (tools.Tool, error) {
+	// verify source exists
+	rawS, ok := srcs[cfg.Source]
+	if !ok {
+		return nil, fmt.Errorf("no source named %q configured", cfg.Source)
+	}
+
+	// verify the source is compatible
+	s, ok := rawS.(*mongosrc.Source)
+	if !ok {
+		return nil, fmt.Errorf("invalid source for %q tool: source kind must be `mongodb`", kind)
+	}
+
+	// Create a slice for all parameters
+	allParameters := slices.Concat(cfg.FilterParams)
+
+	// Verify no duplicate parameter names
+	err := tools.CheckDuplicateParameters(allParameters)
+	if err != nil {
+		return nil, err
+	}
+
+	// Create Toolbox manifest
+	paramManifest := allParameters.Manifest()
+
+	if paramManifest == nil {
+		paramManifest = make([]tools.ParameterManifest, 0)
+	}
+
+	// Create MCP manifest
+	mcpManifest := tools.McpManifest{
+		Name:        cfg.Name,
+		Description: cfg.Description,
+		InputSchema: allParameters.McpManifest(),
+	}
+
+	// finish tool setup
+	return Tool{
+		Name:          cfg.Name,
+		Kind:          kind,
+		AuthRequired:  cfg.AuthRequired,
+		Collection:    cfg.Collection,
+		FilterPayload: cfg.FilterPayload,
+		FilterParams:  cfg.FilterParams,
+		AllParams:     allParameters,
+		database:      s.Client.Database(cfg.Database),
+		manifest:      tools.Manifest{Description: cfg.Description, Parameters: paramManifest, AuthRequired: cfg.AuthRequired},
+		mcpManifest:   mcpManifest,
+	}, nil
+}
+
+// validate interface
+var _ tools.Tool = Tool{}
+
+type Tool struct {
+	Name          string           `yaml:"name"`
+	Kind          string           `yaml:"kind"`
+	AuthRequired  []string         `yaml:"authRequired"`
+	Description   string           `yaml:"description"`
+	Collection    string           `yaml:"collection"`
+	FilterPayload string           `yaml:"filterPayload"`
+	FilterParams  tools.Parameters `yaml:"filterParams"`
+	AllParams     tools.Parameters `yaml:"allParams"`
+
+	database    *mongo.Database
+	manifest    tools.Manifest
+	mcpManifest tools.McpManifest
+}
+
+func (t Tool) Invoke(ctx context.Context, params tools.ParamValues) (any, error) {
+	paramsMap := params.AsMap()
+
+	filterString, err := tools.PopulateTemplateWithJSON("MongoDBDeleteManyFilter", t.FilterPayload, paramsMap)
+	if err != nil {
+		return nil, fmt.Errorf("error populating filter: %s", err)
+	}
+
+	opts := options.Delete()
+
+	var filter = bson.D{}
+	err = bson.UnmarshalExtJSON([]byte(filterString), false, &filter)
+	if err != nil {
+		return nil, err
+	}
+
+	res, err := t.database.Collection(t.Collection).DeleteMany(ctx, filter, opts)
+	if err != nil {
+		return nil, err
+	}
+
+	if res.DeletedCount == 0 {
+		return nil, errors.New("no document found")
+	}
+
+	// not much to return actually
+	return res.DeletedCount, nil
+}
+
+func (t Tool) ParseParams(data map[string]any, claims map[string]map[string]any) (tools.ParamValues, error) {
+	return tools.ParseParams(t.AllParams, data, claims)
+}
+
+func (t Tool) Manifest() tools.Manifest {
+	return t.manifest
+}
+
+func (t Tool) McpManifest() tools.McpManifest {
+	return t.mcpManifest
+}
+
+func (t Tool) Authorized(verifiedAuthServices []string) bool {
+	return tools.IsAuthorized(t.AuthRequired, verifiedAuthServices)
+}

internal/tools/mongodb/mongodbdeletemany/mongodbdeletemany_test.go

@@ -0,0 +1,140 @@
+// Copyright 2025 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package mongodbdeletemany_test
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/googleapis/genai-toolbox/internal/tools"
+	"github.com/googleapis/genai-toolbox/internal/tools/mongodb/mongodbdeletemany"
+
+	yaml "github.com/goccy/go-yaml"
+	"github.com/google/go-cmp/cmp"
+	"github.com/googleapis/genai-toolbox/internal/server"
+	"github.com/googleapis/genai-toolbox/internal/testutils"
+)
+
+func TestParseFromYamlMongoQuery(t *testing.T) {
+	ctx, err := testutils.ContextWithNewLogger()
+	if err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
+	tcs := []struct {
+		desc string
+		in   string
+		want server.ToolConfigs
+	}{
+		{
+			desc: "basic example",
+			in: `
+			tools:
+				example_tool:
+					kind: mongodb-delete-many
+					source: my-instance
+					description: some description
+					database: test_db
+					collection: test_coll
+					filterPayload: |
+					    { name: {{json .name}} }
+					filterParams:
+                        - name: name 
+                          type: string
+                          description: small description
+			`,
+			want: server.ToolConfigs{
+				"example_tool": mongodbdeletemany.Config{
+					Name:          "example_tool",
+					Kind:          "mongodb-delete-many",
+					Source:        "my-instance",
+					AuthRequired:  []string{},
+					Database:      "test_db",
+					Collection:    "test_coll",
+					Description:   "some description",
+					FilterPayload: "{ name: {{json .name}} }\n",
+					FilterParams: tools.Parameters{
+						&tools.StringParameter{
+							CommonParameter: tools.CommonParameter{
+								Name: "name",
+								Type: "string",
+								Desc: "small description",
+							},
+						},
+					},
+				},
+			},
+		},
+	}
+	for _, tc := range tcs {
+		t.Run(tc.desc, func(t *testing.T) {
+			got := struct {
+				Tools server.ToolConfigs `yaml:"tools"`
+			}{}
+			// Parse contents
+			err := yaml.UnmarshalContext(ctx, testutils.FormatYaml(tc.in), &got)
+			if err != nil {
+				t.Fatalf("unable to unmarshal: %s", err)
+			}
+			if diff := cmp.Diff(tc.want, got.Tools); diff != "" {
+				t.Fatalf("incorrect parse: diff %v", diff)
+			}
+		})
+	}
+
+}
+
+func TestFailParseFromYamlMongoQuery(t *testing.T) {
+	ctx, err := testutils.ContextWithNewLogger()
+	if err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
+	tcs := []struct {
+		desc string
+		in   string
+		err  string
+	}{
+		{
+			desc: "Invalid method",
+			in: `
+			tools:
+				example_tool:
+					kind: mongodb-delete-many
+					source: my-instance
+					description: some description
+					collection: test_coll
+					filterPayload: |
+					  { name : {{json .name}} }
+			`,
+			err: `unable to parse tool "example_tool" as kind "mongodb-delete-many"`,
+		},
+	}
+	for _, tc := range tcs {
+		t.Run(tc.desc, func(t *testing.T) {
+			got := struct {
+				Tools server.ToolConfigs `yaml:"tools"`
+			}{}
+			// Parse contents
+			err := yaml.UnmarshalContext(ctx, testutils.FormatYaml(tc.in), &got)
+			if err == nil {
+				t.Fatalf("expect parsing to fail")
+			}
+			errStr := err.Error()
+			if !strings.Contains(errStr, tc.err) {
+				t.Fatalf("unexpected error string: got %q, want substring %q", errStr, tc.err)
+			}
+		})
+	}
+
+}

internal/tools/mongodb/mongodbdeleteone/mongodbdeleteone.go

@@ -0,0 +1,174 @@
+// Copyright 2025 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+package mongodbdeleteone
+
+import (
+	"context"
+	"fmt"
+	"slices"
+
+	"github.com/goccy/go-yaml"
+	mongosrc "github.com/googleapis/genai-toolbox/internal/sources/mongodb"
+	"go.mongodb.org/mongo-driver/bson"
+	"go.mongodb.org/mongo-driver/mongo"
+	"go.mongodb.org/mongo-driver/mongo/options"
+
+	"github.com/googleapis/genai-toolbox/internal/sources"
+	"github.com/googleapis/genai-toolbox/internal/tools"
+)
+
+const kind string = "mongodb-delete-one"
+
+func init() {
+	if !tools.Register(kind, newConfig) {
+		panic(fmt.Sprintf("tool kind %q already registered", kind))
+	}
+}
+
+func newConfig(ctx context.Context, name string, decoder *yaml.Decoder) (tools.ToolConfig, error) {
+	actual := Config{Name: name}
+	if err := decoder.DecodeContext(ctx, &actual); err != nil {
+		return nil, err
+	}
+	return actual, nil
+}
+
+type Config struct {
+	Name          string           `yaml:"name" validate:"required"`
+	Kind          string           `yaml:"kind" validate:"required"`
+	Source        string           `yaml:"source" validate:"required"`
+	AuthRequired  []string         `yaml:"authRequired" validate:"required"`
+	Description   string           `yaml:"description" validate:"required"`
+	Database      string           `yaml:"database" validate:"required"`
+	Collection    string           `yaml:"collection" validate:"required"`
+	FilterPayload string           `yaml:"filterPayload" validate:"required"`
+	FilterParams  tools.Parameters `yaml:"filterParams" validate:"required"`
+}
+
+// validate interface
+var _ tools.ToolConfig = Config{}
+
+func (cfg Config) ToolConfigKind() string {
+	return kind
+}
+
+func (cfg Config) Initialize(srcs map[string]sources.Source) (tools.Tool, error) {
+	// verify source exists
+	rawS, ok := srcs[cfg.Source]
+	if !ok {
+		return nil, fmt.Errorf("no source named %q configured", cfg.Source)
+	}
+
+	// verify the source is compatible
+	s, ok := rawS.(*mongosrc.Source)
+	if !ok {
+		return nil, fmt.Errorf("invalid source for %q tool: source kind must be `mongodb`", kind)
+	}
+
+	// Create a slice for all parameters
+	allParameters := slices.Concat(cfg.FilterParams)
+
+	// Verify no duplicate parameter names
+	err := tools.CheckDuplicateParameters(allParameters)
+	if err != nil {
+		return nil, err
+	}
+
+	// Create Toolbox manifest
+	paramManifest := allParameters.Manifest()
+
+	if paramManifest == nil {
+		paramManifest = make([]tools.ParameterManifest, 0)
+	}
+
+	// Create MCP manifest
+	mcpManifest := tools.McpManifest{
+		Name:        cfg.Name,
+		Description: cfg.Description,
+		InputSchema: allParameters.McpManifest(),
+	}
+
+	// finish tool setup
+	return Tool{
+		Name:          cfg.Name,
+		Kind:          kind,
+		AuthRequired:  cfg.AuthRequired,
+		Collection:    cfg.Collection,
+		FilterPayload: cfg.FilterPayload,
+		FilterParams:  cfg.FilterParams,
+		AllParams:     allParameters,
+		database:      s.Client.Database(cfg.Database),
+		manifest:      tools.Manifest{Description: cfg.Description, Parameters: paramManifest, AuthRequired: cfg.AuthRequired},
+		mcpManifest:   mcpManifest,
+	}, nil
+}
+
+// validate interface
+var _ tools.Tool = Tool{}
+
+type Tool struct {
+	Name          string           `yaml:"name"`
+	Kind          string           `yaml:"kind"`
+	AuthRequired  []string         `yaml:"authRequired"`
+	Description   string           `yaml:"description"`
+	Collection    string           `yaml:"collection"`
+	FilterPayload string           `yaml:"filterPayload"`
+	FilterParams  tools.Parameters `yaml:"filterParams"`
+	AllParams     tools.Parameters `yaml:"allParams"`
+
+	database    *mongo.Database
+	manifest    tools.Manifest
+	mcpManifest tools.McpManifest
+}
+
+func (t Tool) Invoke(ctx context.Context, params tools.ParamValues) (any, error) {
+	paramsMap := params.AsMap()
+
+	filterString, err := tools.PopulateTemplateWithJSON("MongoDBDeleteOneFilter", t.FilterPayload, paramsMap)
+	if err != nil {
+		return nil, fmt.Errorf("error populating filter: %s", err)
+	}
+
+	opts := options.Delete()
+
+	var filter = bson.D{}
+	err = bson.UnmarshalExtJSON([]byte(filterString), false, &filter)
+	if err != nil {
+		return nil, err
+	}
+
+	res, err := t.database.Collection(t.Collection).DeleteOne(ctx, filter, opts)
+	if err != nil {
+		return nil, err
+	}
+
+	// do not return an error when the count is 0, to mirror the delete many call result
+	return res.DeletedCount, nil
+}
+
+func (t Tool) ParseParams(data map[string]any, claims map[string]map[string]any) (tools.ParamValues, error) {
+	return tools.ParseParams(t.AllParams, data, claims)
+}
+
+func (t Tool) Manifest() tools.Manifest {
+	return t.manifest
+}
+
+func (t Tool) McpManifest() tools.McpManifest {
+	return t.mcpManifest
+}
+
+func (t Tool) Authorized(verifiedAuthServices []string) bool {
+	return tools.IsAuthorized(t.AuthRequired, verifiedAuthServices)
+}

internal/tools/mongodb/mongodbdeleteone/mongodbdeleteone_test.go

@@ -0,0 +1,140 @@
+// Copyright 2025 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package mongodbdeleteone_test
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/googleapis/genai-toolbox/internal/tools"
+	"github.com/googleapis/genai-toolbox/internal/tools/mongodb/mongodbdeleteone"
+
+	yaml "github.com/goccy/go-yaml"
+	"github.com/google/go-cmp/cmp"
+	"github.com/googleapis/genai-toolbox/internal/server"
+	"github.com/googleapis/genai-toolbox/internal/testutils"
+)
+
+func TestParseFromYamlMongoQuery(t *testing.T) {
+	ctx, err := testutils.ContextWithNewLogger()
+	if err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
+	tcs := []struct {
+		desc string
+		in   string
+		want server.ToolConfigs
+	}{
+		{
+			desc: "basic example",
+			in: `
+			tools:
+				example_tool:
+					kind: mongodb-delete-one
+					source: my-instance
+					description: some description
+					database: test_db
+					collection: test_coll
+					filterPayload: |
+					    { name: {{json .name}} }
+					filterParams:
+                        - name: name 
+                          type: string
+                          description: small description
+			`,
+			want: server.ToolConfigs{
+				"example_tool": mongodbdeleteone.Config{
+					Name:          "example_tool",
+					Kind:          "mongodb-delete-one",
+					Source:        "my-instance",
+					AuthRequired:  []string{},
+					Database:      "test_db",
+					Collection:    "test_coll",
+					Description:   "some description",
+					FilterPayload: "{ name: {{json .name}} }\n",
+					FilterParams: tools.Parameters{
+						&tools.StringParameter{
+							CommonParameter: tools.CommonParameter{
+								Name: "name",
+								Type: "string",
+								Desc: "small description",
+							},
+						},
+					},
+				},
+			},
+		},
+	}
+	for _, tc := range tcs {
+		t.Run(tc.desc, func(t *testing.T) {
+			got := struct {
+				Tools server.ToolConfigs `yaml:"tools"`
+			}{}
+			// Parse contents
+			err := yaml.UnmarshalContext(ctx, testutils.FormatYaml(tc.in), &got)
+			if err != nil {
+				t.Fatalf("unable to unmarshal: %s", err)
+			}
+			if diff := cmp.Diff(tc.want, got.Tools); diff != "" {
+				t.Fatalf("incorrect parse: diff %v", diff)
+			}
+		})
+	}
+
+}
+
+func TestFailParseFromYamlMongoQuery(t *testing.T) {
+	ctx, err := testutils.ContextWithNewLogger()
+	if err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
+	tcs := []struct {
+		desc string
+		in   string
+		err  string
+	}{
+		{
+			desc: "Invalid method",
+			in: `
+			tools:
+				example_tool:
+					kind: mongodb-delete-one
+					source: my-instance
+					description: some description
+					collection: test_coll
+					filterPayload: |
+					  { name : {{json .name}} }
+			`,
+			err: `unable to parse tool "example_tool" as kind "mongodb-delete-one"`,
+		},
+	}
+	for _, tc := range tcs {
+		t.Run(tc.desc, func(t *testing.T) {
+			got := struct {
+				Tools server.ToolConfigs `yaml:"tools"`
+			}{}
+			// Parse contents
+			err := yaml.UnmarshalContext(ctx, testutils.FormatYaml(tc.in), &got)
+			if err == nil {
+				t.Fatalf("expect parsing to fail")
+			}
+			errStr := err.Error()
+			if !strings.Contains(errStr, tc.err) {
+				t.Fatalf("unexpected error string: got %q, want substring %q", errStr, tc.err)
+			}
+		})
+	}
+
+}