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.

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!

rivendell

MCP server for Rivendell, a workspace where AI agents collaborate on threaded discussions with resolutions. Provides tools for agents to create threads, reply with structured verdicts, and manage project context.

io.github.taylorwilsdon/workspace-mcp

Provides natural language control over Google Workspace services including Gmail, Drive, Calendar, Docs, Sheets, Slides, Forms, Tasks, Contacts, and Chat through all MCP clients.

codex-mcp

A lightweight local coding MCP server that exposes a single project directory to ChatGPT via Streamable HTTP, enabling file operations, command execution, search, and web fetching without authentication.

Remember Me

Here are a few options for translating "MCP server to persist chat artefacts and rules," depending on the specific context: **Option 1 (General):** * **Spanish:** Servidor MCP para persistir artefactos de chat y reglas. * This is a direct translation and works well if you're simply stating the purpose of the server. **Option 2 (More descriptive):** * **Spanish:** Servidor MCP para almacenar de forma persistente artefactos de chat y reglas. * This option uses "almacenar" (to store) which can be more descriptive. **Option 3 (Focus on data retention):** * **Spanish:** Servidor MCP para la persistencia de artefactos de chat y reglas. * This option emphasizes the persistence of the data itself. **Option 4 (More technical):** * **Spanish:** Servidor MCP para persistir artefactos de chat y reglas (almacenamiento persistente). * This option includes "(almacenamiento persistente)" which translates to "(persistent storage)" for added clarity in a technical context. **Which option is best depends on the context. Consider:** * **Your audience:** Are they technical or non-technical? * **The specific function:** Are you emphasizing storage, persistence, or something else? I would lean towards **Option 1 (Servidor MCP para persistir artefactos de chat y reglas.)** unless you have a specific reason to choose a different option. It's clear and concise.

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.

Echo MCP Server

A simple demonstration MCP server that provides an echo tool and resource for learning how to build MCP servers. Serves as a starting point and template for creating custom MCP server implementations.

obol

Enables AI agents to access Solana wallet analytics, token data, and DeFi tools via pay-per-request USDC micropayments using the x402 protocol, without API keys or subscriptions.

qwen-dap-mcp

Enables coding agents to connect to Debug Adapter Protocol debuggers over MCP, allowing them to launch or attach to native targets, control execution, set breakpoints and watchpoints, inspect stacks, variables, memory, and exceptions, and capture agent-friendly debugger snapshots.

Nightshift

MCP server that enables agents to manage DataHub incidents, recall past incident memory, guard columns against regression, and write postmortems into the data graph.

vertaaux-mcp

MCP server for VertaaUX.ai — run UX & accessibility audits, generate fixes, and monitor quality from your LLM or IDE. 38 tools covering the full audit-to-fix lifecycle across 7 UX categories.

zenvoy-mcp

MCP server for the Zenvoy Markdown notes app, providing 26 tools for vault operations like reading, creating, searching notes, and managing tasks, templates, and comments.

overseerr-mcp-server

FastMCP server to interact with the Overseerr API for movie and TV show requests management, enabling users to request media, search, and manage libraries via natural language.

hiveclear

MCP server for agent treasury management. Creates yield-bearing vaults, manages USDC deposits, and runs programmable time-based payment streams between agents.

MCP Calculator Server

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

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.

LibreLink MCP Server

Enables access to FreeStyle Libre glucose data through Claude Desktop, providing current readings, historical data, statistics, and trend analysis from LibreLinkUp accounts with secure credential storage.

NFTGo MCP Server

Provides access to NFTGo's Developer API for retrieving NFT collection details, asset information, market data, wallet information, and search capabilities on the Ethereum blockchain.

binance-alpha-mcp

binance-alpha-mcp

mobile-release-mcp

MCP server for managing mobile app releases on App Store Connect and Google Play. It exposes 101 tools for iOS and Android release lifecycle and reacts to EAS/GitHub webhooks automatically.

Arachne MCP Server

MCP server providing tools for web scraping, browser automation, computer vision, audio transcription, and RAG via API.

Qiniu Cloud Storage MCP Server

A server that enables uploading files to Qiniu Cloud Storage through a standardized MCP interface, providing a simple way to store and serve files with public URLs.

LQABR MCP HubSpot Server

Enables AI agents to read from and write to HubSpot CRM using upsert and get lead profile tools, with Google Cloud Run authentication and secret management.

notebooklm-mcp-pro

Production-grade Model Context Protocol server for Google NotebookLM that lets any MCP-capable client (Claude, ChatGPT, Cursor, etc.) interact with NotebookLM notebooks, sources, chats, and artifacts.

CLI-Anything · ArcGIS Pro

Drive Esri's ArcGIS Pro from an AI agent — the ArcGIS Pro counterpart to QGIS MCP. A headless ArcPy CLI plus an in-process .NET 8 add-in that exposes the live Pro session as MCP tools (ping, zoom_to, query, run_gp, export_layout) so an agent drives the running project while you watch.

io.github.AndrewVG23/grocery-mcp

A dedicated MCP and REST service that searches grocery retailers directly and returns reviewable product links, enabling users to find products and create handoffs without adding to carts or placing orders.

Trusgent MCP

Enables AI agents to search and verify Hong Kong official registry data, retrieve merged agent profiles with citation-safe recommendedUse, and access verified Agent Cards through a remote streamable HTTP endpoint.