Discover Awesome MCP Servers

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.

macOS Notification MCP

macOS Notification MCP

codeledgerECF/codeledger

Deterministic context selection for AI coding agents. Scores and selects the minimal file set for each task, then records outcomes into a local ledger that compounds into reusable patterns.

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!

MCP Action Firewall

A transparent proxy that intercepts high-risk tool calls and requires OTP-based human approval before they can be executed. It acts as a configurable circuit breaker between AI agents and target MCP servers to prevent unauthorized or dangerous actions.

meta-mcp

MCP server for Instagram Graph API, Threads API & Meta platform — posting, insights, comments, messaging

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.

MCP Uplink

A CLI and cloud platform providing managed hosting for MCP servers with intelligent tool filtering to reduce token costs and improve LLM accuracy. It serves as a secure proxy that connects AI clients to cloud tools while keeping sensitive credentials on the local machine.

PingOne Advanced Identity Cloud MCP Server

Enables AI assistants to interact with PingOne Advanced Identity Cloud environments through natural language, supporting user management, authentication theme customization, log analysis, and identity data queries with secure OAuth 2.0 authentication.

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.

astrbot-mcp

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

Metro Logs MCP

Captures and provides access to React Native console logs from Metro bundler, enabling AI assistants to retrieve, filter, and search app logs in real-time without manual copy/paste.

CLI Builder AI MCP

CLI Builder AI - MCP server providing AI-powered tools and automation by MEOK AI Labs

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.

MySQL MCP Server by CData

MySQL MCP Server by CData

skykeep-mcp-server

MCP Server for Skykeep Application

PayPal MCP Server by CData

This read-only MCP Server allows you to connect to PayPal data from Claude Desktop through CData JDBC Drivers. Free (beta) read/write servers available at https://www.cdata.com/solutions/mcp

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.

misata-mcp

Generate realistic multi-table synthetic datasets from plain English. Supports 18 industry domains, narrative growth curves (Black Friday, Q4 spike, 10x MRR), and 15 locale packs. Works with Claude Desktop, Cursor, Windsurf, Zed, and Continue.

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.

Filament MCP Server

Enables AI assistants to build and manage Filament admin panels by providing component references, implementation plans, and official documentation lookups. It supports Laravel's Filament framework versions 4.x and 5.x through specialized tools and prompts.

Slack Enterprise MCP Server

Enterprise-grade Slack integration with compliance audit trails for AI agents. Every action is logged locally for governance, regulatory compliance, and security review.

mcp-dotnet

Enables LLMs to read .NET assemblies as C# by providing tools to list types, decompile types, decompile assemblies, and search decompiled source.

Manus Credit Optimizer

An MCP server that reduces Manus AI credit usage by up to 75% through intelligent prompt compression, smart model routing, and intent classification. It provides tools to analyze and optimize prompts for maximum efficiency without sacrificing quality.

MCP SmallEdit

Provides tools for making small, targeted edits to files using stream editors like sed and awk, enabling efficient modifications without full file replacement.