Discover Awesome MCP Servers

MCP Server

An implementation of the Model Context Protocol (MCP) server that enables multiple clients to connect simultaneously and handles basic context management and messaging with an extendable architecture.

DataDog MCP Server

Enables AI assistants to interact with DataDog's observability platform through a standardized interface. Supports monitoring infrastructure, managing events, analyzing logs and metrics, and automating operations like alerts and downtimes.

Go-MCP

Criar seus próprios servidores MCP (Minecraft Protocol) com Golang.

DeepSeek Server

Fornece recursos de geração e conclusão de código usando a API DeepSeek, com suporte para encadeamento de ferramentas e otimização de custos.

Postman MCP Server

Um servidor MCP que permite executar coleções Postman usando Newman, permitindo que LLMs executem testes de API e obtenham resultados detalhados através de uma interface padronizada.

AutoBrowser MCP

Autobrowser MCP is a Model Context Provider (MCP) server that allows AI applications to control your browser

MCP Notion Server

MCP server for using the Notion API

Task Trellis MCP

An MCP server for Task Trellis that provides tools for AI coding agents to manage tasks, currently featuring a simple hello_world demonstration tool.

Cloudflare Playwright MCP

A server that enables AI assistants to control a browser through tools, allowing them to perform web automation tasks like navigation, typing, clicking, and taking screenshots.

MCP Twitter

Um servidor de Protocolo de Contexto de Modelo que permite que modelos e aplicações de IA interajam diretamente com o Twitter/X, fornecendo capacidades para criar publicações, responder a tweets, recuperar dados de usuários e gerenciar ações de conta.

Self-hosted LLM MCP Server

Enables interaction with self-hosted LLM models via Ollama and Supabase database operations. Supports text generation, SQL queries, and data storage/retrieval through natural language commands.

MCP Dependencies Installer

Instalar todas as dependências para o servidor MCP.

MCP Atlassian Server

A Model Context Protocol server that connects AI assistants like Cline to Atlassian Jira and Confluence, enabling them to query data and perform actions through a standardized interface.

MCP OpenAI Image Generation Server

Enables AI assistants to generate and edit images through OpenAI's DALL-E models via MCP tools. Supports text-to-image generation and image-to-image editing with configurable parameters for size, quality, and style.

MCP Add Server

A minimal Model Context Protocol server that provides a simple add(a, b) tool for computing the sum of two numbers.

WeiWanMcpServer

Servidor Mcp Privado

富途 MCP 服务器 (Futu MCP Server)

Exposes Futu API client capabilities as an MCP (Model Context Protocol) tool, allowing AI assistants to access stock data from Futu through a standardized interface.

solana-launchpads-mcp

An MCP server that tracks daily activity and graduate metrics across multiple Solana launchpads.

Cisco ISE MCP Server

Enables management of Cisco Identity Services Engine (ISE) resources through the ERS API. Supports identity management, endpoint registration, network device configuration, and authorization profiles through natural language interactions.

HubSpot MCP Server

Uma implementação de servidor que permite que assistentes de IA interajam com dados do HubSpot CRM, possibilitando a criação e o gerenciamento contínuos de contatos e empresas, a recuperação do histórico de atividades e o acesso a dados de engajamento por meio de comandos em linguagem natural.

BluestoneApps Development Standards (Remote)

Implementa o Protocolo de Contexto do Modelo (MCP) sobre HTTP para fornecer acesso remoto aos padrões de codificação da BluestoneApps e exemplos de código React Native.

Google Calendar MCP Server

Servidor de Protocolo de Contexto de Modelo que fornece acesso contínuo à API do Google Calendar com suporte a operações assíncronas, permitindo o gerenciamento eficiente do calendário por meio de uma interface padronizada.

Slidespeak

Okay, I understand. You want to know how to generate PowerPoint presentations using the Slidespeak API. Here's a breakdown of how to do that, along with important considerations: **Understanding the Slidespeak API** The Slidespeak API allows you to programmatically create and manipulate PowerPoint presentations. You'll typically interact with it using HTTP requests (like POST, GET, PUT, DELETE) to send instructions and receive responses. **General Steps to Generate a PowerPoint Presentation** 1. **Sign Up and Get an API Key:** * You'll need to create an account on the Slidespeak platform and obtain an API key. This key is essential for authenticating your requests. The Slidespeak documentation will guide you through this process. 2. **Choose a Programming Language and Library:** * Select a programming language you're comfortable with (e.g., Python, JavaScript, Java, PHP, Ruby). * Use an HTTP client library in your chosen language to make requests to the Slidespeak API. Examples: * **Python:** `requests` * **JavaScript:** `fetch`, `axios` * **Java:** `HttpClient` (from Apache HttpComponents) * **PHP:** `curl` * **Ruby:** `net/http` 3. **Understand the Slidespeak API Endpoints and Data Structures:** * **Crucially, consult the Slidespeak API documentation.** This is the most important step. The documentation will tell you: * The base URL for the API. * The specific endpoints for creating presentations, adding slides, adding text, images, etc. * The format of the data you need to send in your requests (usually JSON). * The format of the responses you'll receive. * Authentication methods (usually using your API key in a header). 4. **Construct Your API Requests:** * **Create a Presentation:** Typically, you'll start by making a POST request to an endpoint like `/presentations` or `/createPresentation`. You might provide a title for the presentation in the request body. * **Add Slides:** Next, you'll add slides to the presentation. This usually involves a POST request to an endpoint like `/presentations/{presentationId}/slides` or `/addSlide`. You might specify a layout for the slide (e.g., title slide, title and content, blank). * **Add Content to Slides:** For each slide, you'll add text, images, shapes, etc. This will involve POST or PUT requests to endpoints like `/slides/{slideId}/text`, `/slides/{slideId}/image`, `/slides/{slideId}/shape`. You'll need to provide the content (text, image URL, shape type, etc.) and positioning information (coordinates, size). * **Set Formatting:** You can usually control the formatting of text, shapes, and other elements (font, color, size, alignment, etc.) through the API. The Slidespeak documentation will detail the available formatting options. * **Download the Presentation:** Finally, you'll make a GET request to an endpoint like `/presentations/{presentationId}/download` or `/presentations/{presentationId}.pptx` to download the generated PowerPoint file. 5. **Handle API Responses:** * Check the HTTP status code of each response. A status code of 200 (OK) usually indicates success. Other status codes (e.g., 400 Bad Request, 401 Unauthorized, 500 Internal Server Error) indicate errors. * Parse the response body (usually JSON) to extract any relevant information, such as the ID of the created presentation or slide. * Implement error handling to gracefully handle API errors. **Example (Conceptual - Python with `requests`)** ```python import requests import json API_KEY = "YOUR_SLIDESPEAK_API_KEY" # Replace with your actual API key BASE_URL = "https://api.slidespeak.com/v1" # Replace with the actual Slidespeak API base URL def create_presentation(title): url = f"{BASE_URL}/presentations" headers = { "Authorization": f"Bearer {API_KEY}", "Content-Type": "application/json" } data = {"title": title} response = requests.post(url, headers=headers, data=json.dumps(data)) if response.status_code == 201: # Assuming 201 Created is the success code return response.json()["id"] # Assuming the response contains the presentation ID else: print(f"Error creating presentation: {response.status_code} - {response.text}") return None def add_slide(presentation_id, layout="title_and_content"): url = f"{BASE_URL}/presentations/{presentation_id}/slides" headers = { "Authorization": f"Bearer {API_KEY}", "Content-Type": "application/json" } data = {"layout": layout} response = requests.post(url, headers=headers, data=json.dumps(data)) if response.status_code == 201: return response.json()["id"] # Assuming the response contains the slide ID else: print(f"Error adding slide: {response.status_code} - {response.text}") return None def add_text_to_slide(slide_id, text, x, y, width, height): url = f"{BASE_URL}/slides/{slide_id}/text" headers = { "Authorization": f"Bearer {API_KEY}", "Content-Type": "application/json" } data = { "text": text, "x": x, "y": y, "width": width, "height": height } response = requests.post(url, headers=headers, data=json.dumps(data)) if response.status_code == 200: return True else: print(f"Error adding text: {response.status_code} - {response.text}") return False def download_presentation(presentation_id, filename="presentation.pptx"): url = f"{BASE_URL}/presentations/{presentation_id}/download" # Or maybe f"{BASE_URL}/presentations/{presentation_id}.pptx" headers = { "Authorization": f"Bearer {API_KEY}" } response = requests.get(url, headers=headers, stream=True) # stream=True for large files if response.status_code == 200: with open(filename, "wb") as f: for chunk in response.iter_content(chunk_size=8192): f.write(chunk) print(f"Presentation downloaded to {filename}") return True else: print(f"Error downloading presentation: {response.status_code} - {response.text}") return False # Example Usage presentation_id = create_presentation("My Awesome Presentation") if presentation_id: slide_id = add_slide(presentation_id) if slide_id: add_text_to_slide(slide_id, "Hello, Slidespeak!", 100, 100, 500, 50) download_presentation(presentation_id) ``` **Important Considerations and Best Practices:** * **Rate Limiting:** Be aware of the Slidespeak API's rate limits. If you exceed the limits, your requests may be throttled or blocked. Implement error handling and retry mechanisms to deal with rate limiting. * **Error Handling:** Implement robust error handling to catch API errors and handle them gracefully. Log errors for debugging purposes. * **Data Validation:** Validate the data you're sending to the API to ensure it's in the correct format and within the allowed ranges. * **Asynchronous Operations:** For complex presentations, consider using asynchronous operations to avoid blocking your main thread. This is especially important for web applications. * **API Documentation is Key:** I cannot stress this enough. The Slidespeak API documentation is your bible. Refer to it constantly. The example code above is *illustrative* and *will not work* without the correct API endpoints and data structures from the Slidespeak documentation. * **Security:** Protect your API key. Do not hardcode it directly into your code, especially if you're sharing your code publicly. Use environment variables or a configuration file to store your API key. * **Testing:** Thoroughly test your code to ensure it generates presentations correctly and handles errors gracefully. **In summary, to use the Slidespeak API, you need to:** 1. **Get an API key.** 2. **Study the Slidespeak API documentation.** 3. **Use a programming language and HTTP client library to make requests to the API.** 4. **Construct your requests according to the API documentation.** 5. **Handle the API responses and errors.** Good luck! Let me know if you have more specific questions after reviewing the Slidespeak API documentation.

Remote MCP Server (Authless)

A tool for deploying an authentication-free Model Context Protocol server on Cloudflare Workers that can be connected to AI clients like Claude Desktop or the Cloudflare AI Playground.

tavily-mcp

tavily-mcp

RunwayML + Luma AI MCP Server

Fornece ferramentas para interagir com as APIs do RunwayML e Luma AI para geração de vídeo e imagem, incluindo texto para vídeo, imagem para vídeo, aprimoramento de prompt e gerenciamento de gerações.