Discover Awesome MCP Servers

skykeep-mcp-server

MCP Server for Skykeep Application

MCP Outlook - Microsoft Outlook Integration for Claude

MCP Server and CLI for Microsoft Outlook integration

Solodit MCP Server

A server that allows searching and retrieving Solodit vulnerability reports through Model Context Protocol (MCP).

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

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.

Blawx MCP Server

Enables interaction with the Blawx API to discover project ontologies, ask questions using fact scenarios, and retrieve detailed, step-by-step explanations of logic-based answers. It allows agents to browse project content and drill down into model attributes and constraint satisfaction for rule-based reasoning.

MCP Knowledge Service

Enables semantic search and management of development knowledge including global rules, project documentation, and references through vector-based search using libSQL. Features Tailscale-secured access control and tools for searching, browsing, and organizing development resources across multiple channels.

GitHub MCP Server

Enables AI assistants to analyze GitHub repository structures and read file contents with features like directory traversal, file type analysis, syntax highlighting, and code pattern detection. Supports both public and private repositories through GitHub API integration.

Nornir MCP Server

A FastMCP server that provides network automation tools by exposing Nornir and NAPALM operations as MCP tools, allowing users to manage and interact with network devices through compatible MCP clients.

MCP-Discord

A Discord MCP server that enables AI assistants to interact with Discord platforms, providing functionalities like sending messages, managing channels, creating forum posts, and handling webhooks.

Claude Historian

MCP server that lets you search your Claude Code conversation history to find past solutions, track file changes, and learn from previous work.

NotebookLM MCP Server

Enables interaction with Google's NotebookLM through natural language to create and manage notebooks, add sources from URLs/YouTube/Drive, perform AI-powered research and analysis, and generate audio overviews, videos, infographics, and slide decks from research content.

MSC MCP Server

Enables control of Android devices through ADB, allowing users to list connected devices, capture screenshots using multiple methods (adb, droidcast, minicap, mumu), and retrieve device information.

LinkedIn MCP Server

Enables users to search for jobs, retrieve profiles, and fetch feed posts through the LinkedIn API. It also provides tools for analyzing and extracting data from PDF resumes.

Firecrawl Simple MCP Server

Servidor MCP para Firecrawl Simple — una herramienta de web scraping y mapeo de sitios que permite a los LLMs acceder y procesar contenido web.

MCP Namecheap Server

Provides integration with the Namecheap API for domain management operations, including domain listing, availability checks, and nameserver configuration. It allows users to interact with their Namecheap account through natural language commands in MCP-compatible clients.

MCP Data Analyzer

Enables loading and statistical analysis of .xlsx and .csv files with visualization capabilities using matplotlib and plotly to generate various graphs and charts.

JS Reverse MCP

An MCP server for JavaScript reverse engineering that enables AI to perform browser debugging, script analysis, and automated hook injection. It streamlines complex workflows like deobfuscation, network tracing, and risk assessment through direct browser integration.

photographi-mcp

A Local Computer Vision Engine for Photo Libraries

Uniswap Trader MCP

Enables AI agents to automate token swaps on Uniswap DEX across multiple blockchains including Ethereum, Optimism, Polygon, Arbitrum, and more, with real-time price quotes, swap execution, and multi-hop route optimization.

Newsletter MCP Server

A Multi-Agent Collaboration Protocol server that automates newsletter creation by integrating Slack, Google Docs, and Gmail tools into a streamlined workflow.

MCP Calculator Server

Provides mathematical calculation tools including basic operations, expressions, and functions, along with TypeScript SDK documentation resources and meeting summary prompt templates.

gemini-cli-mcp

A secure MCP server that wraps the Google Gemini CLI, allowing clients to query Gemini models using local OAuth sessions without requiring an API key. It provides tools for model interaction and diagnostics with built-in protection against command injection.

VibeCoding System

An AI-guided conversation-driven development framework that helps build MVPs and POCs rapidly through intelligent dialogue with specialized MCP services.

kivv

Automated arXiv research paper discovery and AI-powered summarization system that enables Claude Desktop users to search, retrieve, and get intelligent summaries of academic papers through MCP integration.

TypeScript MCP Server Boilerplate

A boilerplate project for quickly developing Model Context Protocol (MCP) servers using TypeScript SDK, with example tools (calculator, greet) and resources (server info) pre-implemented.