Spring AI MCP: Detailed explanation of seamless integration of AI agents and local data is here!

With the rapid development of artificial intelligence, the Large Language Model (LLM) has become the core engine of enterprise digital transformation.

However, the capabilities of the model are often limited by the scope of the input data. How to inject massive data from local files, databases, and even external APIs into the model has become a major challenge for technical personnel.

Recently, Spring AI  launched the MCP (Model Context Protocol) integration solution , which provides a standardized answer to this problem.

Through the MCP protocol, developers can easily connect local data sources, databases, and even remote services to AI agents, just like connecting USB devices, and build complex applications with context-aware capabilities.

This article will comprehensively analyze the ecological value of Spring AI MCP from technical principles, practical cases to future trends.

Spring AI MCP provides Java developers with a solution that is deeply integrated with the MCP protocol.

Its core components include:

Analysis of key components:

1. Function Callbacks Spring AI MCP passed
McpFunctionCallbackConvert MCP tools to standard Spring AI function calls.

For example, when the model needs to query a local file,McpFunctionCallbackThis triggers the communication between the MCP Client and the Server, and eventually returns the file content to the model as the context.

2. ChatClient integration developers only need to inject
McpFunctionCallback, you can let the model dynamically call external tools in the conversation. The following code shows the simplicity of this process:

java@Beanpublic ChatClient chatClient(McpSyncClient mcpClient) { List<McpFunctionCallback> callbacks = mcpClient.listTools(null) .tools() .stream() .map(tool -> new McpFunctionCallback(mcpClient, tool)) .collect(Collectors.toList()); return chatClientBuilder.defaultFunctions(callbacks).build(); }

Example demonstration:

Step 1: Components used

1. MCP Client, the key to integration with MCP, provides the ability to interact with the local file system.

2. Function Callbacks, Spring AI MCP's function calling declaration method.

3. Chat Client, a key component of Spring AI, used for LLM model interaction and intelligent agent agent.

Step 2: Declare ChatClient

// List<McpFunctionCallback> functionCallbacks;var chatClient = chatClientBuilder.defaultFunctions(functionCallbacks).build();

Here we first define a ChatClient Bean to interact with the large model as a proxy .

Step 3: Declare MCP Function Callbacks

The following code interacts with the MCP server through mcpClient and adapts MCP to a standard Spring AI function through McpFunctionCallback.

1. Find the list of tools (called functions in Spring AI) available in the MCP server.
2. Convert each tool into a Spring AI function callback in turn.
3. Eventually we will register these McpFunctionCallback to ChatClient for use.

@Beanpublic List<McpFunctionCallback> functionCallbacks(McpSyncClient mcpClient) { return mcpClient.listTools(null) .tools() .stream() .map(tool -> new McpFunctionCallback(mcpClient, tool)) .toList();}

From the above, we can see that the interaction between ChatClient and the model is imperceptible. The model tells ChatClient to make function calls when necessary.

However, Spring AI delegates the actual function call process to MCP through McpFunctionCallback and interacts with the local file system through the standard MCP protocol:

• In the process of interacting with the big model, ChatClient handles the related function call requests;
• ChatClient calls the MCP tool (via McpClient);
• McpClient interacts with the MCP server (i.e., filesystem);

Step 4: Initialize McpClient

The agent application uses a synchronous MCP client to communicate with a locally running file system MCP server:

@Bean ( destroyMethod =  "close" )public  McpSyncClient mcpClient () {    var  stdioParams = ServerParameters. builder ( "npx" )            .args ( "-y" ,  "@modelcontextprotocol/server-filesystem" , "  path))            .build(); // 1
    var mcpClient = McpClient.sync(new StdioServerTransport(stdioParams),            Duration.ofSeconds(10), new ObjectMapper()); //2
    var init = mcpClient.initialize(); // 3    System.out.println(" MCP Initialized :  " + init);
    return mcpClient;}

Run the example, here are the prerequisites to note:

1. Install npx (Node Package eXecute) First, make sure npm ^[4] is installed on your local machine , then run the following command:

npm install -g npx

2. Download the sample source code

git clone https://github.com/springaialibaba/spring-ai-alibaba-examples.gitcd spring-ai-alibaba-examples/spring-ai-alibaba-mcp-example/filesystem

3. Set environment variables

# Tongyi model Dashscope API-KEYexport AI_DASHSCOPE_API_KEY=${your-api-key-here}

4. Build the Example

./mvnw clean install

Step 6: Run the example

The agent will ask questions to the model and can view the output results through the console.

./mvnw spring-boot:run

At this point the example demonstration is successfully completed!

Last words

From local files to enterprise databases, from real-time APIs to IoT devices, the MCP protocol is redefining how AI interacts with data.

With its strong ecological compatibility and ease of use, Spring AI MCP provides developers with a key to open the era of intelligent agents.

Whether you are building a personal assistant or an enterprise application, mastering MCP will give you a head start in the AI ​​race.