Discover Awesome MCP Servers

Build

Okay, I can help you understand how to use the TypeScript SDK to create different MCP (Model Configuration Protocol) servers. However, I need a little more information to give you the *most* helpful and specific answer. Please tell me: 1. **What MCP server are you trying to create?** Are you trying to create a custom MCP server for a specific game, or are you trying to create a generic MCP server? 2. **What TypeScript SDK are you referring to?** There are many TypeScript SDKs that could be used to create an MCP server. Please provide the name of the SDK or a link to the documentation. 3. **What functionality do you need?** What specific features do you need your MCP server to support? For example, do you need to support authentication, authorization, or data validation? In the meantime, here's a general outline of how you might approach creating an MCP server using TypeScript, assuming you're building a custom server and not using a pre-built SDK (which would have its own specific instructions): **General Approach (Custom Implementation):** 1. **Project Setup:** * Initialize a new TypeScript project: ```bash mkdir my-mcp-server cd my-mcp-server npm init -y npm install typescript --save-dev npm install express body-parser cors --save # Common dependencies for a web server npm install --save-dev @types/node @types/express @types/body-parser @types/cors # Type definitions npx tsc --init # Initialize tsconfig.json ``` * Configure `tsconfig.json`: Adjust settings like `target`, `module`, `outDir`, `rootDir`, `esModuleInterop`, and `strict` to suit your project's needs. A basic example: ```json { "compilerOptions": { "target": "es6", "module": "commonjs", "outDir": "./dist", "rootDir": "./src", "strict": true, "esModuleInterop": true, "skipLibCheck": true, "forceConsistentCasingInFileNames": true }, "include": ["src/**/*"], "exclude": ["node_modules"] } ``` 2. **Define Data Structures (Interfaces/Types):** * Create TypeScript interfaces or types to represent the data structures used in the MCP protocol. This will depend entirely on the specific MCP protocol you're implementing. For example: ```typescript // src/types/mcp.ts export interface ModelConfiguration { modelId: string; version: number; parameters: { [key: string]: any }; } export interface MCPRequest { requestId: string; action: "get" | "set" | "delete"; modelId?: string; configuration?: ModelConfiguration; } export interface MCPResponse { requestId: string; status: "success" | "error"; data?: ModelConfiguration | null; error?: string; } ``` 3. **Implement the Server (using Express.js):** * Create an Express.js server to handle MCP requests. ```typescript // src/index.ts import express, { Request, Response } from 'express'; import bodyParser from 'body-parser'; import cors from 'cors'; import { MCPRequest, MCPResponse, ModelConfiguration } from './types/mcp'; const app = express(); const port = 3000; app.use(cors()); app.use(bodyParser.json()); // In-memory storage (replace with a database in a real application) const modelConfigurations: { [modelId: string]: ModelConfiguration } = {}; app.post('/mcp', (req: Request, res: Response) => { const mcpRequest: MCPRequest = req.body; console.log("Received MCP Request:", mcpRequest); switch (mcpRequest.action) { case "get": if (!mcpRequest.modelId) { sendErrorResponse(res, mcpRequest.requestId, "Model ID is required for 'get' action."); return; } const config = modelConfigurations[mcpRequest.modelId]; if (config) { sendSuccessResponse(res, mcpRequest.requestId, config); } else { sendSuccessResponse(res, mcpRequest.requestId, null); // Model not found } break; case "set": if (!mcpRequest.configuration) { sendErrorResponse(res, mcpRequest.requestId, "Configuration is required for 'set' action."); return; } if (!mcpRequest.configuration.modelId) { sendErrorResponse(res, mcpRequest.requestId, "Model ID is required in the configuration for 'set' action."); return; } modelConfigurations[mcpRequest.configuration.modelId] = mcpRequest.configuration; sendSuccessResponse(res, mcpRequest.requestId, mcpRequest.configuration); break; case "delete": if (!mcpRequest.modelId) { sendErrorResponse(res, mcpRequest.requestId, "Model ID is required for 'delete' action."); return; } delete modelConfigurations[mcpRequest.modelId]; sendSuccessResponse(res, mcpRequest.requestId, null); break; default: sendErrorResponse(res, mcpRequest.requestId, "Invalid action."); } }); function sendSuccessResponse(res: Response, requestId: string, data: ModelConfiguration | null) { const response: MCPResponse = { requestId: requestId, status: "success", data: data, }; res.json(response); } function sendErrorResponse(res: Response, requestId: string, errorMessage: string) { const response: MCPResponse = { requestId: requestId, status: "error", error: errorMessage, }; res.status(400).json(response); } app.listen(port, () => { console.log(`MCP Server listening at http://localhost:${port}`); }); ``` 4. **Implement MCP Logic:** * Implement the core logic for handling MCP requests. This will involve: * Parsing the request. * Validating the request. * Retrieving, updating, or deleting model configurations. * Constructing the response. 5. **Data Storage:** * Choose a data storage mechanism to store model configurations. This could be: * In-memory storage (for simple prototypes). * A file-based database (e.g., SQLite). * A relational database (e.g., PostgreSQL, MySQL). * A NoSQL database (e.g., MongoDB, Redis). 6. **Error Handling:** * Implement robust error handling to gracefully handle invalid requests, data validation errors, and other potential issues. 7. **Authentication and Authorization (if needed):** * If your MCP server needs to be secure, implement authentication and authorization mechanisms to control access to model configurations. 8. **Build and Run:** * Compile the TypeScript code: `npm run build` (or `tsc` if you haven't configured a build script). * Run the server: `node dist/index.js` **Example Request (using `curl`):** ```bash curl -X POST -H "Content-Type: application/json" -d '{ "requestId": "123", "action": "set", "configuration": { "modelId": "myModel", "version": 1, "parameters": { "param1": "value1", "param2": 123 } } }' http://localhost:3000/mcp ``` **Important Considerations:** * **Security:** If your MCP server will be exposed to a network, security is paramount. Use HTTPS, implement authentication and authorization, and carefully validate all input. * **Scalability:** If you anticipate a high volume of requests, consider using a scalable architecture, such as a load balancer and multiple server instances. * **Monitoring:** Implement monitoring to track the health and performance of your MCP server. * **Testing:** Write unit tests and integration tests to ensure that your MCP server is working correctly. **Example `package.json` (with build script):** ```json { "name": "my-mcp-server", "version": "1.0.0", "description": "", "main": "index.js", "scripts": { "build": "tsc", "start": "node dist/index.js", "dev": "ts-node-dev --respawn src/index.ts" }, "keywords": [], "author": "", "license": "ISC", "dependencies": { "body-parser": "^1.20.2", "cors": "^2.8.5", "express": "^4.18.2" }, "devDependencies": { "@types/body-parser": "^1.19.5", "@types/cors": "^2.8.17", "@types/express": "^4.17.21", "@types/node": "^20.10.5", "ts-node-dev": "^2.0.0", "typescript": "^5.3.3" } } ``` **To run this example:** 1. Save the code into the appropriate files (e.g., `src/index.ts`, `src/types/mcp.ts`). 2. Run `npm install` to install dependencies. 3. Run `npm run build` to compile the TypeScript code. 4. Run `npm start` to start the server. **Next Steps:** Provide more details about the specific MCP server you're trying to create, the SDK you're using, and the functionality you need, and I can give you more tailored guidance.

MCP Think

A Model Context Protocol server that provides AI assistants like Claude with a dedicated space for structured thinking during complex problem-solving tasks.

FastAPI MCP-Style Server

A minimal FastAPI implementation that mimics Model Context Protocol functionality with JSON-RPC 2.0 support. Provides basic tools like echo and text transformation through both REST and RPC endpoints for testing MCP-style interactions.

OmniFocus MCP Server

Integração do Claude com o OmniFocus: Permita que LLMs interajam com suas tarefas através do Protocolo de Contexto do Modelo. Adicione, organize e consulte seu banco de dados OmniFocus com comandos em linguagem natural.

Intervals.icu MCP Server

Espelho de

Icypeas MCP Server

A Model Context Protocol server that integrates with the Icypeas API to help users find work emails based on name and company information.

Comedy MCP Server

Okay, here's a breakdown of how you could approach building an MCP (presumably meaning "Minecraft Protocol") server using the C# SDK, enhanced with jokes from JokeAPI to add humor to comments or messages. This is a conceptual outline, as a full implementation would be quite extensive. **Conceptual Outline** 1. **Project Setup (C#):** * Create a new C# console application or class library project in Visual Studio or your preferred IDE. * Install necessary NuGet packages: * A Minecraft Protocol library (e.g., `Minecraft.Net`, `MineSharp`, or similar). The specific package will depend on the Minecraft version you want to support. Search NuGet for "Minecraft Protocol C#" to find suitable options. **Important:** Choose a library that is actively maintained and supports the Minecraft version you're targeting. * `Newtonsoft.Json` (for handling JSON responses from JokeAPI). * `System.Net.Http` (for making HTTP requests to JokeAPI). 2. **Minecraft Protocol Handling:** * **Server Initialization:** Use the chosen Minecraft Protocol library to create a server instance. This will involve: * Binding to a specific IP address and port. * Handling client connections. * Authentication (if required). * **Packet Handling:** Implement handlers for relevant Minecraft packets. The most important ones for this scenario are likely: * `ChatMessage` (or equivalent, depending on the library): This packet contains the text of messages sent by players. * `PlayerList` (or equivalent): To keep track of connected players. * **Player Management:** Maintain a list of connected players and their associated data (e.g., username, UUID). 3. **JokeAPI Integration:** * **HTTP Client:** Create an `HttpClient` instance to make requests to JokeAPI. It's good practice to reuse the same `HttpClient` instance for multiple requests. * **Joke Retrieval Function:** Create a function that: * Makes an HTTP GET request to the JokeAPI endpoint (e.g., `https://v2.jokeapi.dev/joke/Programming,Christmas?blacklistFlags=nsfw,racist,sexist,explicit&safe-mode`). Adjust the categories, blacklist flags, and safe mode settings as needed. * Parses the JSON response from JokeAPI using `Newtonsoft.Json`. * Extracts the joke text (either the `joke` property for single-part jokes or the `setup` and `delivery` properties for two-part jokes). * Handles potential errors (e.g., network issues, invalid JSON). * **Example Joke Retrieval:** ```csharp using System; using System.Net.Http; using System.Threading.Tasks; using Newtonsoft.Json; public class JokeApiHelper { private static readonly HttpClient client = new HttpClient(); public static async Task<string> GetJokeAsync() { try { HttpResponseMessage response = await client.GetAsync("https://v2.jokeapi.dev/joke/Programming,Christmas?blacklistFlags=nsfw,racist,sexist,explicit&safe-mode"); response.EnsureSuccessStatusCode(); // Throw exception if not a success code. string responseBody = await response.Content.ReadAsStringAsync(); dynamic jokeData = JsonConvert.DeserializeObject(responseBody); if (jokeData.type == "single") { return jokeData.joke; } else if (jokeData.type == "twopart") { return $"{jokeData.setup}\n{jokeData.delivery}"; } else { return "No joke found."; } } catch (HttpRequestException e) { Console.WriteLine($"Exception: {e.Message}"); return "Error retrieving joke."; } catch (JsonReaderException e) { Console.WriteLine($"JSON Exception: {e.Message}"); return "Error parsing joke."; } } } ``` 4. **Comment Enhancement Logic:** * **Intercept Chat Messages:** In your `ChatMessage` packet handler, intercept the text of the message. * **Trigger Condition:** Determine when to add a joke. Possibilities include: * A specific command (e.g., `/joke`). * A certain probability (e.g., 10% of messages get a joke appended). * Based on keywords in the message. * **Append Joke:** If the trigger condition is met: * Call the `GetJokeAsync()` function to retrieve a joke. * Append the joke to the original message text. Consider adding a separator (e.g., " - Joke: ") to distinguish the joke from the original message. * **Resend Message:** Send the modified `ChatMessage` packet back to the client (or to all clients, depending on your desired behavior). Make sure you're using the correct method from your Minecraft Protocol library to send packets. 5. **Error Handling and Logging:** * Implement robust error handling throughout the code. Catch exceptions that might occur during network operations, JSON parsing, or Minecraft Protocol handling. * Use a logging framework (e.g., `Serilog`, `NLog`, or even just `Console.WriteLine`) to log important events, errors, and debugging information. 6. **Configuration:** * Externalize configuration settings (e.g., server IP address, port, JokeAPI categories, blacklist flags) into a configuration file (e.g., `appsettings.json`) or environment variables. This makes it easier to modify the server's behavior without recompiling the code. **Example Integration (Illustrative):** ```csharp // Inside your ChatMessage packet handler: string originalMessage = /* Get the message text from the packet */; if (originalMessage.StartsWith("/joke")) { string joke = await JokeApiHelper.GetJokeAsync(); string enhancedMessage = $"{originalMessage} - Joke: {joke}"; // Send the enhancedMessage back to the client (or all clients). // Use the appropriate method from your Minecraft Protocol library. // Example (assuming a hypothetical SendChatMessage function): // SendChatMessage(client, enhancedMessage); } else { // Send the original message as is. // SendChatMessage(client, originalMessage); } ``` **Important Considerations:** * **Minecraft Protocol Library:** The choice of Minecraft Protocol library is crucial. Research and select one that is well-documented, actively maintained, and supports the Minecraft version you want to target. The code will vary significantly depending on the library you choose. * **Asynchronous Operations:** Use `async` and `await` for network operations (e.g., HTTP requests to JokeAPI, sending/receiving Minecraft packets) to avoid blocking the main thread and keep the server responsive. * **Rate Limiting:** Be mindful of JokeAPI's rate limits. Implement a mechanism to avoid exceeding the limits and getting your server blocked. Consider caching jokes locally to reduce the number of API calls. * **Security:** If you're handling authentication, follow security best practices to protect player accounts. * **Testing:** Thoroughly test your server to ensure it handles different scenarios correctly and doesn't crash. * **User Experience:** Consider the user experience. Don't bombard players with jokes too frequently. Provide a way for players to disable the joke feature if they find it annoying. This is a high-level overview. Building a full MCP server with these features would require a significant amount of coding and testing. Start with a basic Minecraft Protocol server implementation and then gradually add the JokeAPI integration and comment enhancement logic. Remember to consult the documentation for your chosen Minecraft Protocol library and JokeAPI for specific details and instructions. Good luck!

semantic-edit-mcp

semantic-edit-mcp

MCP Docker Sandbox Interpreter

A secure Docker-based environment that allows AI assistants to safely execute code without direct access to the host system by running all code within isolated containers.

缔零法则Lawgenesis

缔零法则MCP是基于LLM和RAG技术搭建的实现完全替代人力的全自动化风险识别的内容安全审查平台，致力于通过代理AI技术减少人力成本，高效高精度为用户提供分钟级接入的内容风控解决方案，破解安全威胁，提供从风险感知到主动拦截策略执行的全链路闭环与一体化解决方案。This MCP tool is an AI-powered content security review platform built on LLM and RAG technologies, designed to achieve fully automated risk identification that completel

Parallels RAS MCP Server (Python)

Servidor MCP para Parallels RAS usando FastAPI

Google Search MCP Server

A Model Context Protocol server that provides web and image search capabilities through Google's Custom Search API, allowing AI assistants like Claude to access current information from the internet.

Claude Code DingTalk MCP Server

Integrates Claude Code with DingTalk (钉钉) robot notifications, allowing users to send task completion alerts and various message formats to DingTalk groups from Claude Code.

Devici MCP Server

Provides LLM tools to interact with the Devici API, enabling management of threat modeling resources including users, collections, threat models, components, threats, mitigations, and teams.

46elks MCP Server

Enables AI assistants and MCP-compatible clients to send and manage SMS messages through the 46elks API, leveraging Swedish telecommunications infrastructure.

MCP with Langchain Sample Setup

Okay, here's a sample setup for an MCP (Modular Component Protocol) server and client, designed to be compatible with LangChain. This example focuses on a simple "summarization" task, but you can adapt it to other LangChain functionalities. **Important Considerations:** * **MCP (Modular Component Protocol):** MCP isn't a widely standardized protocol. This example uses a simplified, custom implementation based on JSON over HTTP for demonstration purposes. In a real-world scenario, you might consider more robust solutions like gRPC, Thrift, or even well-defined REST APIs. * **LangChain Integration:** The key is to use LangChain components (e.g., LLMs, chains, document loaders) *within* the MCP server to process requests. The client sends data, the server uses LangChain to process it, and the server returns the result. * **Error Handling:** This is a simplified example. Robust error handling (try-except blocks, logging, proper HTTP status codes) is crucial in a production environment. * **Security:** This example lacks security measures (authentication, authorization). Implement appropriate security based on your needs. * **Asynchronous Operations:** For more complex tasks, consider using asynchronous operations (e.g., `asyncio` in Python) to improve performance and prevent blocking. **Python Code (Example):** **1. MCP Server (using Flask):** ```python from flask import Flask, request, jsonify from langchain.llms import OpenAI from langchain.chains.summarize import load_summarize_chain from langchain.document_loaders import TextLoader # Or other loaders from langchain.text_splitter import CharacterTextSplitter import os # Set your OpenAI API key (or use environment variables) os.environ["OPENAI_API_KEY"] = "YOUR_OPENAI_API_KEY" # Replace with your actual key app = Flask(__name__) @app.route('/summarize', methods=['POST']) def summarize_text(): try: data = request.get_json() text = data.get('text') if not text: return jsonify({'error': 'Missing "text" parameter'}), 400 # LangChain components llm = OpenAI(temperature=0) # Adjust temperature as needed summarize_chain = load_summarize_chain(llm, chain_type="map_reduce") # or "stuff", "refine" # Prepare the document (using a dummy TextLoader for demonstration) # In a real scenario, you might load from a file, database, etc. # For large texts, split into chunks text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0) texts = text_splitter.split_text(text) # Create LangChain documents from the text chunks from langchain.docstore.document import Document docs = [Document(page_content=t) for t in texts] # Run the summarization chain summary = summarize_chain.run(docs) return jsonify({'summary': summary}) except Exception as e: print(f"Error: {e}") # Log the error return jsonify({'error': str(e)}), 500 # Return error with status code if __name__ == '__main__': app.run(debug=True, host='0.0.0.0', port=5000) # Make accessible on network ``` **2. MCP Client (using `requests`):** ```python import requests import json def summarize_with_mcp(text, server_url="http://localhost:5000/summarize"): """ Sends text to the MCP server for summarization. Args: text: The text to summarize. server_url: The URL of the MCP server's summarize endpoint. Returns: The summary from the server, or None if there was an error. """ try: payload = {'text': text} headers = {'Content-Type': 'application/json'} response = requests.post(server_url, data=json.dumps(payload), headers=headers) response.raise_for_status() # Raise HTTPError for bad responses (4xx or 5xx) data = response.json() return data.get('summary') except requests.exceptions.RequestException as e: print(f"Error connecting to server: {e}") return None except json.JSONDecodeError as e: print(f"Error decoding JSON response: {e}") return None except Exception as e: print(f"An unexpected error occurred: {e}") return None if __name__ == '__main__': sample_text = """ This is a long piece of text that needs to be summarized. It contains important information about LangChain and MCP. LangChain is a powerful framework for building applications using large language models. MCP, in this context, is a simple protocol for communication between a client and a server. The server uses LangChain to process requests from the client. This example demonstrates a basic summarization task. More complex tasks can be implemented using different LangChain components and chains. Error handling and security are important considerations for production deployments. """ summary = summarize_with_mcp(sample_text) if summary: print("Summary:", summary) else: print("Failed to get summary.") ``` **Explanation:** * **Server (Flask):** * Uses Flask to create a simple HTTP server. * The `/summarize` endpoint receives POST requests with a JSON payload containing the `text` to summarize. * It initializes LangChain components: `OpenAI` (the LLM) and `load_summarize_chain` (the summarization chain). You'll need an OpenAI API key. * It loads the text into a LangChain `Document`. For larger texts, it splits the text into chunks using `CharacterTextSplitter`. * It runs the summarization chain and returns the summary in a JSON response. * Includes basic error handling. * **Client:** * Uses the `requests` library to send a POST request to the server's `/summarize` endpoint. * It packages the text to be summarized in a JSON payload. * It handles potential errors during the request (e.g., connection errors, bad responses). * It prints the summary received from the server. **How to Run:** 1. **Install Dependencies:** ```bash pip install flask langchain openai requests tiktoken ``` 2. **Set OpenAI API Key:** Replace `"YOUR_OPENAI_API_KEY"` in the server code with your actual OpenAI API key. Consider using environment variables for security. 3. **Run the Server:** ```bash python your_server_file.py # e.g., python mcp_server.py ``` 4. **Run the Client:** ```bash python your_client_file.py # e.g., python mcp_client.py ``` **Key Adaptations for Different LangChain Tasks:** * **Different Chains:** Instead of `load_summarize_chain`, use other LangChain chains (e.g., `LLMChain`, `ConversationalRetrievalChain`) based on the task you want to perform. * **Different LLMs:** Use other LLMs besides `OpenAI` (e.g., `HuggingFaceHub`, `Cohere`). You'll need to install the appropriate LangChain integration and configure the LLM. * **Data Loading:** Use different LangChain document loaders (e.g., `WebBaseLoader`, `CSVLoader`, `PDFMinerLoader`) to load data from various sources. * **Input/Output:** Adjust the input and output data formats in the server and client to match the requirements of your task. For example, you might send a question and receive an answer, or send a list of documents and receive a ranked list of relevant documents. * **Prompt Engineering:** Carefully design the prompts used in your LangChain chains to achieve the desired results. **Example in Portuguese (Translation of the Explanation):** Aqui está uma configuração de exemplo para um servidor e cliente MCP (Modular Component Protocol), projetada para ser compatível com LangChain. Este exemplo se concentra em uma tarefa simples de "resumo", mas você pode adaptá-lo para outras funcionalidades do LangChain. **Considerações Importantes:** * **MCP (Modular Component Protocol):** MCP não é um protocolo amplamente padronizado. Este exemplo usa uma implementação personalizada simplificada baseada em JSON sobre HTTP para fins de demonstração. Em um cenário do mundo real, você pode considerar soluções mais robustas como gRPC, Thrift ou até mesmo APIs REST bem definidas. * **Integração com LangChain:** A chave é usar componentes LangChain (por exemplo, LLMs, chains, carregadores de documentos) *dentro* do servidor MCP para processar solicitações. O cliente envia dados, o servidor usa LangChain para processá-los e o servidor retorna o resultado. * **Tratamento de Erros:** Este é um exemplo simplificado. O tratamento robusto de erros (blocos try-except, registro, códigos de status HTTP adequados) é crucial em um ambiente de produção. * **Segurança:** Este exemplo carece de medidas de segurança (autenticação, autorização). Implemente a segurança apropriada com base em suas necessidades. * **Operações Assíncronas:** Para tarefas mais complexas, considere usar operações assíncronas (por exemplo, `asyncio` em Python) para melhorar o desempenho e evitar bloqueios. **Código Python (Exemplo):** (O código Python permaneceria o mesmo, pois é código e não precisa ser traduzido. Apenas a explicação é traduzida.) **Explicação:** * **Servidor (Flask):** * Usa Flask para criar um servidor HTTP simples. * O endpoint `/summarize` recebe solicitações POST com um payload JSON contendo o `text` a ser resumido. * Ele inicializa os componentes LangChain: `OpenAI` (o LLM) e `load_summarize_chain` (a chain de resumo). Você precisará de uma chave de API OpenAI. * Ele carrega o texto em um `Document` LangChain. Para textos maiores, ele divide o texto em partes usando `CharacterTextSplitter`. * Ele executa a chain de resumo e retorna o resumo em uma resposta JSON. * Inclui tratamento de erros básico. * **Cliente:** * Usa a biblioteca `requests` para enviar uma solicitação POST para o endpoint `/summarize` do servidor. * Ele empacota o texto a ser resumido em um payload JSON. * Ele lida com possíveis erros durante a solicitação (por exemplo, erros de conexão, respostas ruins). * Ele imprime o resumo recebido do servidor. **Como Executar:** (As instruções de execução permanecem as mesmas, pois são comandos e não precisam ser traduzidas.) **Principais Adaptações para Diferentes Tarefas LangChain:** * **Chains Diferentes:** Em vez de `load_summarize_chain`, use outras chains LangChain (por exemplo, `LLMChain`, `ConversationalRetrievalChain`) com base na tarefa que você deseja executar. * **LLMs Diferentes:** Use outros LLMs além de `OpenAI` (por exemplo, `HuggingFaceHub`, `Cohere`). Você precisará instalar a integração LangChain apropriada e configurar o LLM. * **Carregamento de Dados:** Use diferentes carregadores de documentos LangChain (por exemplo, `WebBaseLoader`, `CSVLoader`, `PDFMinerLoader`) para carregar dados de várias fontes. * **Entrada/Saída:** Ajuste os formatos de dados de entrada e saída no servidor e no cliente para corresponder aos requisitos de sua tarefa. Por exemplo, você pode enviar uma pergunta e receber uma resposta, ou enviar uma lista de documentos e receber uma lista classificada de documentos relevantes. * **Engenharia de Prompt:** Projete cuidadosamente os prompts usados em suas chains LangChain para obter os resultados desejados. This provides a basic framework. Remember to adapt it to your specific use case and add proper error handling, security, and performance optimizations. Good luck!

MCP JSON Database Server

A JSON-based database MCP server with JWT authentication that enables user management, project tracking, department analysis, meeting management, and equipment tracking. Integrates with Claude Desktop to provide secure CRUD operations and analytics through natural language commands.

Crowdlistening

Crowdlistening

mcp-test

test

Remote MCP Server Authless

A simple way to deploy an authentication-free Model Context Protocol server on Cloudflare Workers that can be connected to AI tools like Claude Desktop or the Cloudflare AI Playground.

MCP MySQL Server

Enables interaction with MySQL databases (including AWS RDS and cloud instances) through natural language. Supports database connections, query execution, schema inspection, and comprehensive database management operations.

Spotify MCP Server

Um servidor de Protocolo de Controle de Mídia para controlar a reprodução do Spotify.

Meraki Magic MCP

A Python-based MCP server that enables querying Cisco's Meraki Dashboard API to discover, monitor, and manage Meraki environments.

Cursor Rust Tools

Um servidor MCP para permitir que o LLM no Cursor acesse o Rust Analyzer, a documentação de Crate e os comandos Cargo.

qBittorrent MCP

A service that provides programmatic access to qBittorrent's WebUI API, enabling management of torrents, trackers, tags, speed controls, and system information through natural language.

raindrop-mcp

Um servidor MCP para Raindrop.io (serviço de marcação de favoritos).

X MCP Server

Enables users to interact with X (Twitter) through the X API. Supports posting tweets, retrieving user timelines, searching tweets, and replying to tweets with comprehensive error handling.

LINE Bot MCP Server

Model Context Protocol server implementation that integrates the LINE Messaging API to connect AI agents with LINE Official Accounts, enabling agents to send messages to users.