Discover Awesome MCP Servers

Supabase MCP Server 🚀

Espejo de

Cyoda Calculation Node MCP

Enables AI assistants to interact with Cyoda platform entities and workflows through the Model Context Protocol, supporting entity management, workflow execution, and data synchronization.

MCP Weather Server

Provides weather forecasts, alerts, and current conditions via the Model Context Protocol, using simulated data and supporting both stdio and HTTP transports.

Related Identity MCP Server

Discovers related blockchain addresses and domain names for web3 identities across different platforms including Ethereum, Farcaster, Lens, and ENS using next.id's relation server data.

Qontinui MCP Server

Enables AI-driven visual automation by connecting to Qontinui Runner to load workflow configurations, execute visual automation workflows, and monitor execution status across multiple displays.

Spring Ai Mcp Deepseek

Okay, I understand. You want to know how to integrate Spring AI with an MCP (Model Control Plane) service, specifically using an MCP server and a DeepSeek client. Here's a breakdown of the concepts and a general approach to achieve this, along with considerations and potential code snippets (though a complete, runnable example would be quite extensive): **Understanding the Components** * **Spring AI:** A Spring project that provides abstractions and tools for working with AI models, including large language models (LLMs). It simplifies tasks like prompting, model invocation, and result handling. * **MCP (Model Control Plane):** A system that manages the lifecycle of AI models. This includes: * **Model Registry:** Storing model metadata (name, version, location, capabilities). * **Model Deployment:** Deploying models to serving infrastructure. * **Model Monitoring:** Tracking model performance and health. * **Model Governance:** Enforcing policies around model usage. * **MCP Server:** The central component of the MCP, responsible for managing models and providing an API for clients to interact with them. It likely exposes endpoints for: * Listing available models. * Retrieving model metadata. * Invoking models. * **DeepSeek Client:** A client library or API that allows you to interact with DeepSeek models. DeepSeek is a specific LLM provider (like OpenAI, Google, etc.). This client handles authentication, request formatting, and response parsing for the DeepSeek API. **General Approach** The core idea is to create a Spring AI `ChatClient` (or `EmbeddingClient` if you're working with embeddings) that delegates the actual model invocation to the MCP server, which in turn uses the DeepSeek client. Here's a step-by-step outline: 1. **Set up your Spring Boot project:** * Create a new Spring Boot project using Spring Initializr ([https://start.spring.io/](https://start.spring.io/)). * Include the necessary dependencies: * `spring-boot-starter-web`: For building REST APIs. * `spring-ai-core`: The core Spring AI library. * Potentially other Spring AI modules depending on your needs (e.g., `spring-ai-openai` if you want to compare with a direct OpenAI integration). * A suitable HTTP client library (e.g., `spring-boot-starter-webflux` for reactive HTTP or `spring-boot-starter-web` with `RestTemplate`). * Any dependencies required by the DeepSeek client library (if it's a separate library). 2. **Configure the DeepSeek Client:** * Obtain API keys or credentials for DeepSeek. * If the DeepSeek client is a separate library, configure it according to its documentation. This might involve setting API keys, base URLs, and other parameters. 3. **Create a Spring AI `ChatClient` Implementation:** * Create a class that implements the `ChatClient` interface from Spring AI. This is the key part where you bridge Spring AI to your MCP. * **Dependency Injection:** Inject the DeepSeek client (or a service that uses the DeepSeek client) into your `ChatClient` implementation. * **`generate()` Method:** Implement the `generate()` method of the `ChatClient` interface. This method takes a `Prompt` object as input and returns a `ChatResponse`. Inside this method: * Extract the text from the `Prompt`. * Format the request according to the MCP server's API. This might involve creating a JSON payload with the prompt text and any other required parameters. * Send the request to the MCP server's endpoint for model invocation using your HTTP client. * Parse the response from the MCP server. The response should contain the generated text from the DeepSeek model. * Create a `ChatResponse` object from the parsed response and return it. 4. **Configure the MCP Server Interaction:** * **API Endpoint:** Determine the correct API endpoint on the MCP server for invoking the DeepSeek model. * **Authentication:** If the MCP server requires authentication, configure your HTTP client to include the necessary headers (e.g., API key, JWT token). * **Request/Response Format:** Understand the expected request format (e.g., JSON) and the format of the response containing the generated text. 5. **Register the `ChatClient` in Spring:** * Create a Spring configuration class. * Use the `@Bean` annotation to register your custom `ChatClient` implementation as a Spring bean. This makes it available for injection into other components. 6. **Use the `ChatClient` in your application:** * Inject the `ChatClient` into your Spring components (e.g., controllers, services). * Use the `generate()` method to send prompts to the DeepSeek model via the MCP server. **Example Code Snippets (Illustrative)** ```java import org.springframework.ai.chat.ChatClient; import org.springframework.ai.chat.ChatResponse; import org.springframework.ai.chat.prompt.Prompt; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Value; import org.springframework.http.HttpEntity; import org.springframework.http.HttpHeaders; import org.springframework.http.MediaType; import org.springframework.stereotype.Component; import org.springframework.web.client.RestTemplate; import java.util.List; import java.util.Map; @Component public class McpDeepSeekChatClient implements ChatClient { @Value("${mcp.server.url}") private String mcpServerUrl; @Value("${mcp.server.api.key}") private String mcpServerApiKey; @Autowired private RestTemplate restTemplate; // Or WebClient for reactive @Override public ChatResponse generate(Prompt prompt) { String promptText = prompt.getContent(); // 1. Prepare the request to the MCP server String mcpEndpoint = mcpServerUrl + "/deepseek/generate"; // Example endpoint HttpHeaders headers = new HttpHeaders(); headers.setContentType(MediaType.APPLICATION_JSON); headers.set("X-API-Key", mcpServerApiKey); // Example authentication Map<String, String> requestBody = Map.of("prompt", promptText); HttpEntity<Map<String, String>> requestEntity = new HttpEntity<>(requestBody, headers); // 2. Send the request to the MCP server Map response = restTemplate.postForObject(mcpEndpoint, requestEntity, Map.class); // 3. Parse the response from the MCP server String generatedText = (String) response.get("generated_text"); // Adjust based on MCP response format // 4. Create a ChatResponse object ChatResponse chatResponse = new ChatResponse(List.of(new org.springframework.ai.chat.Generation(generatedText))); return chatResponse; } } ``` ```java import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.web.client.RestTemplate; @Configuration public class AppConfig { @Bean public RestTemplate restTemplate() { return new RestTemplate(); } // Register the custom ChatClient @Bean public McpDeepSeekChatClient mcpDeepSeekChatClient() { return new McpDeepSeekChatClient(); } } ``` ```java import org.springframework.ai.chat.ChatClient; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.web.bind.annotation.PostMapping; import org.springframework.web.bind.annotation.RequestBody; import org.springframework.web.bind.annotation.RestController; import org.springframework.ai.chat.prompt.PromptTemplate; import org.springframework.ai.chat.prompt.Prompt; import java.util.Map; @RestController public class ChatController { @Autowired private ChatClient chatClient; @PostMapping("/chat") public String chat(@RequestBody Map<String, String> request) { String userMessage = request.get("message"); PromptTemplate promptTemplate = new PromptTemplate("User message: {message}"); Prompt prompt = promptTemplate.create(Map.of("message", userMessage)); return chatClient.generate(prompt).getReply().getContent(); } } ``` **Important Considerations** * **Error Handling:** Implement robust error handling to catch exceptions during API calls, response parsing, and other operations. * **Asynchronous Communication:** Consider using asynchronous communication (e.g., `WebClient` in Spring WebFlux) for better performance, especially if the MCP server or DeepSeek API has high latency. * **Rate Limiting:** Be aware of rate limits imposed by the MCP server and the DeepSeek API. Implement appropriate retry mechanisms and backoff strategies. * **Security:** Protect your API keys and credentials. Use environment variables or a secure configuration management system to store them. Consider using HTTPS for all communication. * **MCP Server Implementation:** The specific details of interacting with the MCP server will depend on its implementation. You'll need to consult its documentation to understand the API endpoints, request/response formats, and authentication mechanisms. * **DeepSeek Client Library:** If a dedicated DeepSeek client library exists, use it to simplify the interaction with the DeepSeek API. Otherwise, you might need to build your own client using HTTP libraries. * **Model Selection:** The MCP server might allow you to select different DeepSeek models. Make sure to include the model selection parameter in your request to the MCP server if necessary. * **Streaming:** If the DeepSeek API supports streaming responses, consider implementing streaming in your `ChatClient` to provide a more interactive user experience. Spring AI has support for streaming. * **Testing:** Write unit tests and integration tests to verify that your `ChatClient` implementation is working correctly. **In summary, integrating Spring AI with an MCP service involves creating a custom `ChatClient` that acts as a bridge between Spring AI's abstractions and the MCP server's API. You'll need to handle request formatting, response parsing, authentication, and error handling. The specific details will depend on the MCP server's implementation and the DeepSeek client library you're using.** This detailed explanation should give you a solid foundation for building your integration. Remember to consult the documentation for Spring AI, your MCP server, and the DeepSeek API for the most accurate and up-to-date information. Good luck!

AMM

Enables automatic memory retrieval and injection for AI conversations to provide continuous learning through semantic search and memory management.

DF-MCP

El servidor MCP de DreamFactory permite que los asistentes de IA como Claude consulten directamente sus bases de datos a través de las API REST autogeneradas de DreamFactory. Este servidor Node.js implementa el Protocolo de Contexto del Modelo (MCP), lo que permite interacciones con la base de datos en lenguaje natural manteniendo la seguridad de nivel empresarial.

gerbil-mcp

Provides AI assistants with live access to a Gerbil Scheme environment to evaluate expressions, look up module exports, and check syntax. It enables real-time interaction with the gxi runtime for macro expansion and symbol searching.

git-context-mcp

A secure MCP server for local Git operations with path traversal protection, input validation, and 15 supported Git commands.

agentskill-mcp

MCP server for discovering and installing AI agent skills from agentskill.sh. Search skills across platforms, browse trending skills, and install them with built-in security scanning.

ansys-mcp-server

Enables Claude Code to control Ansys engineering simulations (CFD, FEA, meshing, post-processing) through natural language commands via PyAnsys.

is-bankasi-mcp

MCP server for Isbank (Is Bankasi) developer API (Turkey). Enables access to accounts, balances, transactions, exchange rates, transfers, and credit cards via OAuth 2.0 authentication.

xhs-mcp

A lightweight MCP server that provides read-only access to Xiaohongshu (Little Red Book) data, enabling search, note details, user profiles, and trending feeds via direct HTTP APIs.

NCBI Gene MCP Server

MCP server that interfaces with the NCBI Entrez API to fetch detailed information about genes and proteins, enabling gene searches, gene/protein metadata retrieval, and symbol searching with organism filtering.

airlock

MCP server that vets package installations and shell commands to block dangerous actions by AI coding agents.

Capacities MCP Server

Enables search, content creation, weblink saving, and knowledge base analysis with Capacities through any MCP-compatible client.

WordPress MCP

A WordPress plugin that implements the Model Context Protocol to enable AI models and applications to interact with WordPress sites in a structured and secure way.

Sentiment By Api Ninjas MCP Server

Enables sentiment analysis of text blocks using the Api Ninjas API, returning sentiment scores and overall sentiment classification for up to 2000 characters of text.

search-console-mcp

A read-only MCP server for Google Search Console that lets you query search performance data, sitemaps, and URL index status from any MCP client.

Insight Digger MCP

An enterprise-grade data analysis system that enables users to discover data sources, configure analyses, and execute workflows through Claude Desktop. It features intelligent caching, session isolation, and secure JWT authentication for streamlined multi-user data orchestration.

mdgen-mcp

MCP server for mdgen that enables reading, writing, and managing mdgen documents from MCP clients like Claude Desktop and Codex CLI using your own mdgen account.

Skolverket-MCP

Enables easy access to open data from the Swedish National Agency for Education, allowing querying and integration of educational statistics and facts through large language models.

Agnes Image MCP Server

Enables text-to-image generation using Agnes Image 2.1 Flash via OpenAI-compatible API, supporting aspect ratios, custom resolution, and multi-image generation.

astrbot-mcp

Provides tools for AstrBot plugin development including documentation access and hook inventory.

Connhex MCP Server

Enables natural language interaction with Connhex IoT platform APIs for managing devices, telemetry, rules, and resources via MCP tools.

GOAT MCP Server

Un servidor MCP que conecta Claude para Escritorio con funcionalidad blockchain, permitiendo a los usuarios consultar saldos y enviar tokens en cadenas EVM y Solana a través de interacciones en lenguaje natural.

COMSOL MCP Server

Enables AI agents to automate multiphysics simulations in COMSOL Multiphysics, covering model management, geometry building, physics configuration, and results visualization. It supports complex simulation workflows through the MCP protocol and includes integrated knowledge retrieval for documentation and troubleshooting.

Metabase MCP Server

Enables AI assistants to interact with Metabase analytics platform, allowing users to query databases, manage dashboards and cards, execute SQL queries, and access analytics data through natural language.

Parquet MCP Server

Enables querying, modifying, and managing Parquet files with CRUD operations, semantic search, audit logging, and rollback capabilities for structured data storage.