How to Build an MCP Server and Client With Spring AI MCP

TITLE: Building Enterprise-Ready AI Applications with Spring AI MCP: Server and Client Implementation

Introduction to Model Context Protocol in Enterprise AI

The Model Context Protocol (MCP) represents a significant advancement in how AI applications access and utilize external data sources. Developed by Anthropic, MCP provides a standardized framework for enriching AI models with real-time, contextual information from various systems. For enterprises looking to deploy AI solutions that understand their specific business context, MCP offers a robust foundation for building intelligent applications that can access private data sources securely and efficiently.

Introduction to Model Context Protocol in Enterprise AI
Understanding the MCP Architecture
Project Setup and Dependencies
Implementing the MCP Server
Database Schema and Data Modeling
Testing with MCP Inspector
Building the MCP Client Application
Real-World Use Case: Telecom Expense Management
Best Practices for Production Deployment
Conclusion

In this comprehensive guide, we’ll explore how to implement a complete MCP ecosystem using Spring Boot, Spring AI, and Spring AI MCP, creating both server and client components that work together to deliver context-aware AI capabilities. This implementation demonstrates how enterprises can leverage their existing data infrastructure to build AI applications that provide accurate, relevant insights based on proprietary information.

Understanding the MCP Architecture

The Model Context Protocol operates on a client-server model where MCP servers expose tools and resources that MCP clients can utilize to enhance AI model capabilities. The protocol supports multiple transport layers, including HTTP with Server-Sent Events (SSE) for web applications and STDIO for command-line tools. This flexibility makes MCP suitable for various deployment scenarios, from local development environments to cloud-native applications.

What sets MCP apart is its ability to provide structured access to external systems. Instead of relying on generic API calls, MCP defines a standardized way for AI models to discover available tools, understand their capabilities, and invoke them with appropriate parameters. This structured approach ensures that AI models can reliably interact with external systems while maintaining security and control over data access.

Project Setup and Dependencies

To begin building our MCP server and client, we need to establish the proper foundation with the right tools and dependencies. Our implementation uses:, according to industry news

Java 21 for modern language features and performance
Spring Boot 3.5.3 as the application framework
Spring AI 1.0.0 for AI integration capabilities
Spring AI MCP for Model Context Protocol implementation
PostgreSQL as the database backend
Asentinel ORM for lightweight database operations

The key dependency for our MCP server is the Spring AI MCP Server Boot Starter, which provides automatic configuration and setup for MCP servers within Spring Boot applications. This starter includes both HTTP-based transport using Spring MVC with automatically configured SSE endpoints, and optional STDIO transport for command-line usage., according to market insights

Implementing the MCP Server

Our MCP server implementation focuses on providing access to telecom invoice data stored in a PostgreSQL database. The server exposes tools that allow AI models to query and retrieve specific invoice information, enriching their understanding of the business context.

The server configuration begins with properties that define its behavior and capabilities:

spring.ai.mcp.server.name=invoice-server
spring.ai.mcp.server.version=1.0.0
spring.ai.mcp.server.instructions=Provides access to telecom invoice data
spring.ai.mcp.server.transport.web.path=/mcp
spring.ai.mcp.server.capabilities=tools

These properties establish the server identity, version compatibility information, usage instructions for clients, and the endpoint path for client connections. The capabilities property specifies that our server will expose tools for client use.

The core of our MCP server implementation involves defining the tools that will be available to clients. We create a service component that exposes a tool for searching invoices by pattern matching:

@Service
public class InvoiceService {
    
    @Tool(description = "Search invoices by number pattern")
    public List<Invoice> searchInvoices(
        @Parameter(description = "Pattern to search in invoice numbers") 
        String numberPattern) {
        // Implementation to query database and return matching invoices
    }
}

This tool definition uses Spring AI’s annotations to describe the tool’s purpose and parameters, making it discoverable and understandable by MCP clients. The actual implementation leverages Asentinel ORM for database operations, providing a lightweight yet powerful way to interact with our PostgreSQL database.

Database Schema and Data Modeling

Our example uses a simplified telecom invoice schema with a single entity representing invoices. The database table includes attributes such as invoice number, vendor, service type, amount, status, and date fields. This structure allows us to demonstrate key MCP concepts while maintaining clarity in our implementation.

The Invoice entity is mapped to the database table using Asentinel ORM’s annotation-based mapping:

@Table("invoices")
public class Invoice {
    @Id
    private Long id;
    private String invoiceNumber;
    private String vendor;
    private String serviceType;
    private BigDecimal amount;
    private String status;
    private LocalDate invoiceDate;
    // Getters and setters
}

This straightforward mapping demonstrates how MCP can integrate with existing data models without requiring significant changes to your current architecture.

Testing with MCP Inspector

Before integrating our MCP server with client applications, it’s crucial to validate its functionality. The MCP Inspector provides an excellent tool for testing and debugging MCP servers. This web-based interface allows developers to connect to MCP servers, list available tools, and test them with various parameters.

To test our server, we start the MCP Inspector and configure it to connect to our Spring Boot application using HTTP transport with the endpoint URL http://localhost:8081/mcp. Once connected, we can verify that our invoice search tool is properly exposed and functioning as expected.

Building the MCP Client Application

The client application serves as the interface between end-users and the AI model, enhanced with MCP capabilities. Our implementation uses Spring Boot to create a web application that integrates with OpenAI’s API while incorporating an MCP client to access our invoice server.

The client configuration includes MCP client properties that define how to connect to our server:

spring.ai.mcp.client.transport.web.url=http://localhost:8081/mcp
spring.ai.openai.api-key=${OPENAI_API_KEY}

This configuration establishes the connection to our MCP server while setting up the OpenAI integration for chat capabilities., as covered previously

The key integration point in our client application is the chat service, which combines OpenAI’s language model with our MCP tools:

@Service
public class ChatService {
    
    private final OpenAiChatClient chatClient;
    private final McpClient mcpClient;
    
    public String chat(String userMessage) {
        // Use MCP client to gather context from invoice server
        List<Invoice> relevantInvoices = mcpClient.callTool(
            "searchInvoices", 
            extractSearchPattern(userMessage)
        );
        
        // Build enhanced prompt with context
        String enhancedPrompt = buildEnhancedPrompt(userMessage, relevantInvoices);
        
        // Get response from OpenAI with enriched context
        return chatClient.call(enhancedPrompt);
    }
}

This implementation demonstrates how MCP enables AI applications to access specific, relevant data from external systems and incorporate it into the conversation context, resulting in more accurate and useful responses.

Real-World Use Case: Telecom Expense Management

Our implementation addresses a common enterprise challenge: telecom expense management. Users can interact with the AI client using natural language to ask questions about specific invoices, request summaries of spending by vendor or service type, or identify anomalies in billing patterns.

For example, a user might ask: “Show me all unpaid VOIP invoices from Vendor A in August 2025.” The MCP client would:

Parse the query to identify relevant search criteria
Call the appropriate tools on the MCP server to retrieve matching invoices
Enhance the prompt sent to OpenAI with the specific invoice data
Return a natural language response based on the actual data

This workflow demonstrates the power of MCP in bridging the gap between general-purpose AI models and specific business data, creating AI applications that truly understand the enterprise context.

Best Practices for Production Deployment

When moving from development to production, several considerations ensure your MCP implementation is robust, secure, and performant:

Security: Implement proper authentication and authorization for MCP server access
Error Handling: Build comprehensive error handling for network issues and tool failures
Monitoring: Implement logging and monitoring to track tool usage and performance
Resource Management: Ensure proper connection pooling and resource cleanup
Versioning: Maintain compatibility between server and client versions

For more detailed information on MCP concepts and the Java SDK, refer to the official MCP documentation.

Conclusion

The Model Context Protocol represents a significant step forward in building context-aware AI applications. By implementing MCP servers and clients with Spring AI, developers can create powerful AI solutions that leverage enterprise data while maintaining security and control. Our example demonstrates how to build a complete system that enriches AI conversations with specific business data, creating more valuable and accurate interactions.

As AI continues to transform business operations, protocols like MCP will play a crucial role in ensuring that AI systems can access and understand the specific context in which they operate. The Spring AI MCP integration provides a robust, enterprise-ready foundation for building these next-generation AI applications.

For additional insights on Spring AI integration, you might find this resource on Generative AI with Spring Boot helpful for expanding your understanding of AI integration patterns in Spring applications.