mongodb-mcp-server

[fscamuzzi]

Hi I'm trying to implement in a Asp.NET core application using Ollama and qwen3:30b a connection to the mongodb-mcp-server.

It can connect and list all the tools (i can log them) and also call successfully the connect and list database.

But when it try to call the find or aggregate tools in the mcp i get the error like:

asp.net semantik kernel mongodb-mcp-server error:   }
]
[12:27:02 ERR] Function MongoDB-find failed. Error: Request failed (remote): MCP error -32602: Invalid arguments for tool find: [
  {
    "code": "invalid_type",
    "expected": "object",
    "received": "string",
    "path": [
      "projection"
    ],
    "message": "Expected object, received string"
  },
  {
    "code": "invalid_type",
    "expected": "number",
    "received": "string",
    "path": [
      "limit"
    ],
    "message": "Expected number, received string"
  }
]

and also for filter and son on... it looks like it can't translate the query (that i can see and it's corret) to the correct format.

I've tried modify the prompt or call the functions via API (using "custom" plugin) but nothing worked and i'm stuccked.

Any suggestion or example?

Thnx for you time!!!

[eiriktsarpalis]

Superficially, it would appear that the MCP server is rejecting your call inputs because of a type error. Have you checked that your inputs match the advertised schema of the tool? Are you able to call the tool with the same arguments using MCP inspector?

[fscamuzzi]

basically the tool is called by the AI directly (in a first version wihtout any custom plugin). this is an idea of the flow:

 public MongoDbAgentService(
        ILogger<MongoDbAgentService> logger,
        IOptions<KernelSettings> kernelSettings)
    {
        _logger = logger;
        _kernelSettings = kernelSettings;

        // Create a dedicated kernel for the MongoDB agent
        var builder = Kernel.CreateBuilder();

        // Add Ollama chat completion service
        builder.AddOllamaChatCompletion(
            modelId: kernelSettings.Value.modelId,
            endpoint: new Uri(kernelSettings.Value.LLMHost));

        // Add function invocation filter for MCP parameter type conversion --> add this to try force correct typing for mcp parameters
        builder.Services.AddSingleton<IFunctionInvocationFilter>(sp =>
            new McpParameterTypeFilter(logger));

        _kernel = builder.Build();
    }

    public async Task<string> ExecuteQueryAsync(
        string userQuery,
        ChatHistory chatHistory,
        CancellationToken cancellationToken = default)
    {
        try
        {
            // Add MCP MongoDB functions to kernel
            await _kernel.Plugins.AddMcpFunctionsFromStdioServerAsync(
                "MongoDB",
                "/Users/xxxxxx/.nvm/versions/node/v22.12.0/bin/node",
                ["/Users/xxxxx/.nvm/versions/node/v22.12.0/bin/mongodb-mcp-server"],
                environmentVariables: new Dictionary<string, string>
                {
                    { "MDB_MCP_CONNECTION_STRING", _kernelSettings.Value.mongoMcp }
                },
                cancellationToken: cancellationToken);

            // Log loaded MCP functions
            var mcpPlugin = _kernel.Plugins.FirstOrDefault(p => p.Name == "MongoDB");
            if (mcpPlugin != null)
            {
                 // HERE HE LOG ALL TOOLS CORRECTLY
                _logger.LogInformation("MongoDB Agent: Loaded {Count} MCP functions", mcpPlugin.Count());
                foreach (var function in mcpPlugin)
                {
                    _logger.LogDebug("  - {FunctionName}: {Description}",
                        function.Name, function.Description);
                }
            }

            // Create system prompt for MongoDB agent
            var systemPrompt = CreateSystemPrompt();

            // Add system message if not already present
            if (!chatHistory.Any() || chatHistory.First().Role != AuthorRole.System)
            {
                chatHistory.Insert(0, new ChatMessageContent(AuthorRole.System, systemPrompt));
            }

            // Add user query
            chatHistory.AddUserMessage(userQuery);

            // Configure execution settings with auto function calling
            var executionSettings = new OllamaPromptExecutionSettings
            {
                FunctionChoiceBehavior = FunctionChoiceBehavior.Auto(),
                Temperature = 0,
                ModelId = _kernelSettings.Value.modelId,
            };

            // Get chat completion service
            var chatCompletionService = _kernel.GetRequiredService<IChatCompletionService>();

            // Execute agent with auto function calling
            _logger.LogInformation("MongoDB Agent: Processing query: {Query}", userQuery);

            var response = await chatCompletionService.GetChatMessageContentAsync(
                chatHistory,
                executionSettings,
                _kernel,
                cancellationToken);

            _logger.LogInformation("MongoDB Agent: Response generated successfully");

            // Add assistant response to history
            chatHistory.AddAssistantMessage(response.Content ?? "No results available.");

            return response.Content ?? "No results available.";
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "MongoDB Agent: Error executing query: {Query}", userQuery);
            return $"Error executing MongoDB query: {ex.Message}";
        }
    }

    private string CreateSystemPrompt()
    {
        return $@"# MongoDB Query Assistant Agent

You are a specialized AI agent for MongoDB database operations through MCP (Model Context Protocol).

## Your Role
You have direct access to MongoDB database through MCP tools. Your job is to:
1. Understand user requests about MongoDB data
2. Use available MCP tools to query, analyze, and manipulate MongoDB data
3. Present results clearly and concisely in Italian (unless requested otherwise)

## Available MCP Tools
You have access to MongoDB operations including:
- find: Query documents with filters, projections, sorting, and limits
- aggregate: Run aggregation pipelines for complex data analysis
- insert: Add new documents to collections
- update: Modify existing documents
- delete: Remove documents
- listCollections: See available collections
- listDatabases: See available databases

## CRITICAL: Parameter Type Requirements
When calling MCP MongoDB tools, you MUST use correct parameter types:

OBJECT Parameters (filter, sort, projection, update, document, query):
  * These MUST be actual JavaScript objects, NOT JSON strings
  * CORRECT: filter: {{name: ""John"", age: 25}}
  * CORRECT: filter: {{}} (empty object for all documents)
  * INCORRECT: filter: ""{{name: 'John'}}""
  * INCORRECT: filter: ""{{}}""
  * The system will automatically parse JSON strings to objects, but provide objects directly

ARRAY Parameters (pipeline):
  * CORRECT: pipeline: [{{$match: {{age: 25}}}}, {{$limit: 10}}]
  * INCORRECT: pipeline: ""[{{$match: {{age: 25}}}}]""

NUMBER Parameters (limit, skip, batchSize, maxTimeMS):
  * CORRECT: limit: 10
  * INCORRECT: limit: ""10""

BOOLEAN Parameters:
  * CORRECT: true or false
  * INCORRECT: ""true"" or ""false""

## Response Guidelines
1. Always respond in Italian unless the user requests another language
2. If you don't know something, say ""Non lo so"" (I don't know)
3. Execute operations directly using MCP tools - don't just describe what you would do
4. Present query results in a clear, readable format
5. If an operation fails, explain why and suggest corrections
6. Use appropriate indexes and limit results to avoid overwhelming responses

## Database Connection
Active MongoDB connection: {_kernelSettings.Value.mongoMcp}

Remember: You are an ACTION agent - use the tools to actually perform operations, don't just talk about them.
";
    }
}

/// <summary>
/// Filter to ensure MCP tool parameters are properly typed before invocation
/// </summary>
internal sealed class McpParameterTypeFilter : IFunctionInvocationFilter
{
    private readonly ILogger _logger;

    public McpParameterTypeFilter(ILogger logger)
    {
        _logger = logger;
    }

    public async Task OnFunctionInvocationAsync(
        Microsoft.SemanticKernel.FunctionInvocationContext context,
        Func<Microsoft.SemanticKernel.FunctionInvocationContext, Task> next)
    {
        // Only process MCP MongoDB functions
        if (context.Function.PluginName == "MongoDB")
        {
            _logger.LogDebug("Processing MCP function: {FunctionName}", context.Function.Name);

            // Convert string parameters to their proper types based on parameter schema
            foreach (var param in context.Function.Metadata.Parameters)
            {
                if (context.Arguments.ContainsName(param.Name))
                {
                    var value = context.Arguments[param.Name];

                    // Convert string parameters to proper types
                    if (value is string stringValue && !string.IsNullOrEmpty(stringValue))
                    {
                        // Get schema type
                        string? schemaType = null;
                        try
                        {
                            if (param.Schema?.RootElement.TryGetProperty("type", out var typeElement) == true)
                            {
                                schemaType = typeElement.GetString();
                            }
                        }
                        catch (Exception ex)
                        {
                            _logger.LogDebug(ex, "Could not read schema type for parameter {ParamName}", param.Name);
                        }

                        // Known parameter types - hardcoded fallback
                        var numericParams = new[] { "limit", "skip", "batchSize", "maxTimeMS" };
                        var arrayParams = new[] { "pipeline" };
                        var objectParams = new[] { "filter", "sort", "projection", "update", "document", "query" };
                        var isNumericParam = numericParams.Contains(param.Name, StringComparer.OrdinalIgnoreCase);
                        var isArrayParam = arrayParams.Contains(param.Name, StringComparer.OrdinalIgnoreCase);
                        var isObjectParam = objectParams.Contains(param.Name, StringComparer.OrdinalIgnoreCase);

                        _logger.LogInformation("Parameter {ParamName}: schema type={SchemaType}, value={Value}",
                            param.Name, schemaType ?? "unknown", stringValue);

                        // Handle object parameters FIRST (filter, sort, projection, etc)
                        if (schemaType == "object" || isObjectParam || stringValue.TrimStart().StartsWith("{"))
                        {
                            try
                            {
                                var jsonNode = JsonNode.Parse(stringValue);
                                _logger.LogInformation("✓ Converting parameter {ParamName} from JSON string to JsonNode object", param.Name);
                                context.Arguments[param.Name] = jsonNode;
                            }
                            catch (System.Text.Json.JsonException ex)
                            {
                                _logger.LogWarning(ex, "Failed to parse JSON object for parameter {ParamName}: {StringValue}",
                                    param.Name, stringValue);
                            }
                        }
                        // Handle array parameters (like pipeline)
                        else if (schemaType == "array" || isArrayParam || stringValue.TrimStart().StartsWith("["))
                        {
                            try
                            {
                                var jsonNode = JsonNode.Parse(stringValue);
                                if (jsonNode is JsonArray)
                                {
                                    _logger.LogInformation("✓ Converting parameter {ParamName} from JSON string to JsonArray", param.Name);
                                    context.Arguments[param.Name] = jsonNode;
                                }
                                else
                                {
                                    _logger.LogWarning("Parameter {ParamName} parsed but is not an array", param.Name);
                                }
                            }
                            catch (System.Text.Json.JsonException ex)
                            {
                                _logger.LogWarning(ex, "Failed to parse JSON array for parameter {ParamName}: {StringValue}",
                                    param.Name, stringValue);
                            }
                        }
                        // Handle numeric parameters
                        else if (schemaType == "number" || schemaType == "integer" || isNumericParam)
                        {
                            if (int.TryParse(stringValue, out var intValue))
                            {
                                _logger.LogInformation("✓ Converting parameter {ParamName} from string '{StringValue}' to int {IntValue}",
                                    param.Name, stringValue, intValue);
                                context.Arguments[param.Name] = intValue;
                            }
                            else if (double.TryParse(stringValue, out var doubleValue))
                            {
                                _logger.LogInformation("✓ Converting parameter {ParamName} from string '{StringValue}' to double {DoubleValue}",
                                    param.Name, stringValue, doubleValue);
                                context.Arguments[param.Name] = doubleValue;
                            }
                        }
                        // Handle boolean parameters
                        else if (schemaType == "boolean")
                        {
                            if (bool.TryParse(stringValue, out var boolValue))
                            {
                                _logger.LogInformation("✓ Converting parameter {ParamName} from string '{StringValue}' to bool {BoolValue}",
                                    param.Name, stringValue, boolValue);
                                context.Arguments[param.Name] = boolValue;
                            }
                        }
                    }
                }
            }
        }

        await next(context);
    }
}`

[fscamuzzi]

really really appreciate your support and time ... thnx!

Also i can see in some of my tries the correct generated mongodb query (filter , projection and rost etc etc) .. but in string ... and i think the problem is that the generated query is passed as string ..sa far as i can see ..

[eiriktsarpalis]

Sounds like a potential duplicate of #274. I would recommend providing a self-contained repro (aka a console app that runs without additional input and performs the unexpected action).

[fscamuzzi]

Hi

sorry for the delay but it's quite an intensive period :-) .... i've pushed a very basic repository thet reproduce the problem. in this repo there is not Mongodb plugin that try to send the command to the mcp by http client instead it try to invoke it directly but as you can see if you try to run it (i've also added a very basic read me) you'll see the error is the same. let me know if you need also the example with http client.

sorry for the quality of the code

Again thnx for your support!!

link to the repo: (https://github.com/fscamuzzi/net-mongodb-mcp-example)

[eiriktsarpalis]

Thanks, I have the following feedback:

1. Would it be possible to record the expected vs. actual behavior you're recording?
2. I don't have access to MongoDB resources, would it be possible to change the repro so that it doesn't require any API keys? (An alternative MCP server or pointing to a mode in the current server that doesn't require a Mongo DB would help.)

[PederHP]

A few comments:

I am not very familiar with ollama, but generally it's not good practice to hardcode tool signatures in your system prompt. If the tool signature changes on the server side, your prompt will be out of sync and you'll get type errors. If your LLM API does not allow providing JSON schema tools, then you should write code to map the MCP tool schema to a fragment of the system prompt programmatically.

I am also skeptical of the manual mapping of tool calls to invocations. This has the same issue of not being able to handle if the server side tool changes. If you use Microsoft.Extensions.AI this is handled automatically for you, and you don't need to do this. See: https://learn.microsoft.com/en-us/dotnet/ai/microsoft-extensions-ai#tool-calling

The benefit of tools and MCP is that they provide a generic way to ingrate with models. You can still write instructions (like the part about being an ACTION model and not just talking about using tools) but you don't have to manually wire the tools up.

[fscamuzzi]

You're right , I'm sorry it is one of the many tries i've done .. and in the disperation i've also tried this prompt :-)...

but i didn't get where i've hardcoded the tools calls ... if you mean the "MongoDB" .. it is a generic name you want ot give to your mcp ... as far as i understand .. it could also be "xxx"....

Said that .. also with different prompt and different implementation it gives the following error .. if i also tried with wrapping the tools calls in a custom plugin like:

[KernelFunction]
    [Description("Query MongoDB database through MCP server to retrieve information based on user question.")]
    public async Task<string> FindDocuments(
        [Description("The database name")] string database,
        [Description("The collection name")] string collection,
        [Description("MongoDB query filter")] string filter,
        [Description("Optional: Fields to return (projection)")]
        string? projection = null)
    {
        try
        {
            var request = new
            {
                tool = "MongoDB_find",
                // collection = collection,
                // database,
                // filter = JsonSerializer.Deserialize<object>(filter),
                // projection = projection != null ? JsonSerializer.Deserialize<object>(projection) : null

                query = new
                {
                    database,
                    collection,
                    filter = JsonSerializer.Deserialize<object>(filter),
                    projection = projection != null ? JsonSerializer.Deserialize<object>(projection) : null,
                
                }
            };

            var response = await _httpClient.PostAsJsonAsync($"{_mcpEndpoint}/mcp", request);
            var result = await response.Content.ReadAsStringAsync();
            return result;
        }
        catch (Exception ex)
        {
            return $"Error querying MongoDB: {ex.Message}";
        }
    }

i can see that it generates the query correctly (filter and projection are correct) but when i try to pass it to the MCP api it gives type error:
Request failed (remote): MCP error -32602: Invalid arguments for tool aggregate: [ { "code": "invalid_type", "expected": "array", "received": "string", "path": [ "pipeline" ], "message": "Expected array, received string" } ]

this is error for the aggregate but the same for find etc etc (limit is a string etc etc)

[fscamuzzi]

Quick Update!! ... with the https://learn.microsoft.com/en-us/dotnet/ai/microsoft-extensions-ai#tool-calling you just link it seems work!! .. GREAT .. now i'll try more test .. But really big up and thnx!!! for you support and time !!!

THNX!