# Directory Structure
```
├── .gitignore
├── pom.xml
├── README.md
└── src
└── main
├── java
│ └── com
│ └── bootcamptoprod
│ ├── config
│ │ └── McpConfiguration.java
│ ├── service
│ │ └── MongoServiceClient.java
│ └── SpringBootAiMongoMcpServerApplication.java
└── resources
└── application.properties
```
# Files
--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
```
# Compiled class file
*.class
# Log file
*.log
# BlueJ files
*.ctxt
# Mobile Tools for Java (J2ME)
.mtj.tmp/
# Package Files #
*.jar
*.war
*.nar
*.ear
*.zip
*.tar.gz
*.rar
# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
hs_err_pid*
replay_pid*
.idea
target
```
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
```markdown
# Mongo MCP Server
This project is a Mongo MCP Server built with Spring Boot AI. It is designed to interact with a local MongoDB instance and expose various database operations as callable tools. The server can be tested using any MCP client, including the Claude desktop app.
For a detailed explanation on how to build an MCP server, check out our blog:
**[Build MCP Servers with Spring Boot AI: A Beginner’s Guide](https://bootcamptoprod.com/build-mcp-servers-with-spring-boot-ai/)**
---
## Features
- **MongoDB Integration:** Connects to a local MongoDB instance to perform various operations.
- **Callable Tools:** Exposes methods using the `@Tool` annotation, making them accessible as services.
- **Tool Registration:** Uses `ToolCallbackProvider` to register and expose the available functionalities.
- **Testable with MCP Clients:** Easily test the server using any MCP client, including the Claude desktop app.
---
```
--------------------------------------------------------------------------------
/src/main/java/com/bootcamptoprod/SpringBootAiMongoMcpServerApplication.java:
--------------------------------------------------------------------------------
```java
package com.bootcamptoprod;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class SpringBootAiMongoMcpServerApplication {
public static void main(String[] args) {
SpringApplication.run(SpringBootAiMongoMcpServerApplication.class, args);
}
}
```
--------------------------------------------------------------------------------
/src/main/resources/application.properties:
--------------------------------------------------------------------------------
```
spring.application.name=spring-boot-ai-mongo-mcp-server
spring.main.banner-mode=off
spring.main.web-application-type=none
logging.file.name=./logs/spring-boot-ai-mongo-mcp-server.log
logging.pattern.console=
spring.ai.mcp.server.name=mongo-mcp-server
spring.ai.mcp.server.version=0.0.1
# MongoDB connection string
mongodb.uri=mongodb://${MONGO_HOST}:${MONGO_PORT}
```
--------------------------------------------------------------------------------
/src/main/java/com/bootcamptoprod/config/McpConfiguration.java:
--------------------------------------------------------------------------------
```java
package com.bootcamptoprod.config;
import com.bootcamptoprod.service.MongoServiceClient;
import org.springframework.ai.tool.ToolCallbackProvider;
import org.springframework.ai.tool.method.MethodToolCallbackProvider;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class McpConfiguration {
@Bean
public ToolCallbackProvider mongoTools(MongoServiceClient mongoServiceClient) {
return MethodToolCallbackProvider.builder().toolObjects(mongoServiceClient).build();
}
}
```
--------------------------------------------------------------------------------
/pom.xml:
--------------------------------------------------------------------------------
```
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>3.4.5</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<groupId>com.bootcamptoprod</groupId>
<artifactId>spring-boot-ai-mongo-mcp-server</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>spring-boot-ai-mongo-mcp-server</name>
<description>A Spring Boot AI-powered Model Context Protocol Server for interacting with MongoDB</description>
<properties>
<java.version>21</java.version>
<spring-ai.version>1.0.0-M7</spring-ai.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.ai</groupId>
<artifactId>spring-ai-starter-mcp-server</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-mongodb</artifactId>
</dependency>
</dependencies>
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework.ai</groupId>
<artifactId>spring-ai-bom</artifactId>
<version>${spring-ai.version}</version>
<type>pom</type>
<scope>import</scope>
</dependency>
</dependencies>
</dependencyManagement>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>
```
--------------------------------------------------------------------------------
/src/main/java/com/bootcamptoprod/service/MongoServiceClient.java:
--------------------------------------------------------------------------------
```java
package com.bootcamptoprod.service;
import com.mongodb.client.MongoClient;
import com.mongodb.client.MongoClients;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;
import org.bson.Document;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.ai.tool.annotation.Tool;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import java.util.ArrayList;
import java.util.List;
@Service
public class MongoServiceClient {
private static final Logger logger = LoggerFactory.getLogger(MongoServiceClient.class);
private final MongoClient mongoClient;
/**
* Initializes the MongoDB client with the given URI.
*/
public MongoServiceClient(@Value("${mongodb.uri}") String mongoUri) {
logger.info("Initializing MongoServiceClient with URI: {}", mongoUri);
this.mongoClient = MongoClients.create(mongoUri);
}
/**
* Lists all databases in MongoDB.
*/
@Tool(description = "List all databases in MongoDB.")
public List<String> listDatabases() {
logger.info("Fetching list of databases.");
List<String> databaseNames = new ArrayList<>();
for (Document db : mongoClient.listDatabases()) {
databaseNames.add(db.getString("name"));
}
logger.info("Databases found: {}", databaseNames);
return databaseNames;
}
/**
* Lists all collections in the specified database.
*/
@Tool(description = "List all collections in the specified database.")
public List<String> listCollections(String dbName) {
logger.info("Fetching collections for database: {}", dbName);
List<String> collectionNames = new ArrayList<>();
MongoDatabase database = mongoClient.getDatabase(dbName);
for (String name : database.listCollectionNames()) {
collectionNames.add(name);
}
logger.info("Collections found in {}: {}", dbName, collectionNames);
return collectionNames;
}
/**
* Executes a simple query on a collection.
*/
@Tool(description = "Execute a simple query on a collection.")
public List<Document> simpleQuery(String dbName, String collectionName, String field, Object value) {
logger.info("Executing simple query on {}.{} where {} = {}", dbName, collectionName, field, value);
MongoCollection<Document> collection = mongoClient.getDatabase(dbName).getCollection(collectionName);
List<Document> results = new ArrayList<>();
collection.find(new Document(field, value)).into(results);
logger.info("Query returned {} results.", results.size());
return results;
}
/**
* Executes a complex query on a collection.
*/
@Tool(description = "Execute a complex query on a collection.")
public List<Document> complexQuery(String dbName, String collectionName, String jsonQuery) {
logger.info("Executing complex query on {}.{} with query: {}", dbName, collectionName, jsonQuery);
MongoCollection<Document> collection = mongoClient.getDatabase(dbName).getCollection(collectionName);
Document query = Document.parse(jsonQuery);
List<Document> results = new ArrayList<>();
collection.find(query).into(results);
logger.info("Complex query returned {} results.", results.size());
return results;
}
/**
* Lists all indexes for a specific collection.
*/
@Tool(description = "List all indexes for a specific collection.")
public List<Document> listIndexes(String dbName, String collectionName) {
logger.info("Fetching indexes for {}.{}", dbName, collectionName);
MongoCollection<Document> collection = mongoClient.getDatabase(dbName).getCollection(collectionName);
List<Document> indexes = new ArrayList<>();
collection.listIndexes().into(indexes);
logger.info("Indexes found: {}", indexes);
return indexes;
}
/**
* Creates a new collection in the specified database.
*/
@Tool(description = "Create a new collection in the specified database.")
public String createCollection(String dbName, String collectionName) {
logger.info("Creating collection '{}' in database '{}'", collectionName, dbName);
MongoDatabase database = mongoClient.getDatabase(dbName);
database.createCollection(collectionName);
logger.info("Collection '{}' created successfully.", collectionName);
return "Collection '" + collectionName + "' created successfully in database '" + dbName + "'.";
}
/**
* Inserts a document into a collection.
*/
@Tool(description = "Insert a document into a collection.")
public String insertDocument(String dbName, String collectionName, String jsonDocument) {
logger.info("Inserting document into {}.{}: {}", dbName, collectionName, jsonDocument);
MongoCollection<Document> collection = mongoClient.getDatabase(dbName).getCollection(collectionName);
Document document = Document.parse(jsonDocument);
collection.insertOne(document);
logger.info("Document inserted successfully into {}.{}", dbName, collectionName);
return "Document inserted successfully into collection '" + collectionName + "'.";
}
}
```