Discover Awesome MCP Servers

outlty-mcp

Exposes FastAPI API-key management and request-making routes as MCP tools, enabling users to manage and interact with their APIs via Claude.

Vercel MCP Server Template

A starter template for deploying Model Context Protocol (MCP) servers on Vercel using TypeScript and Vercel Functions. It includes example tools for rolling dice and checking weather to demonstrate tool integration patterns.

supertonic3-mcp

Enables local text-to-speech synthesis for Claude and Cursor using Supertonic 3, with support for multiple voices, expressions, and languages. No API key or cloud required.

Polarion MCP Server

A TypeScript MCP server that turns the Polarion ALM REST API into a tool-based interface for AI assistants.

Excel MCP Server

Enables conversational data analysis of Excel/CSV files through natural language queries, powered by 395 Excel functions via HyperFormula and multi-provider AI. Supports advanced analytics, bulk operations, financial modeling, and large file processing with intelligent chunking.

claude-remind-mcp

Searches your local Claude Code conversation history to recall and resume past solutions.

filesystem-ops

MCP server for performing filesystem operations, enabling file management and manipulation through natural language.

SQLite Project Memory MCP

A graph-friendly relational server that stores project memory, tasks, and metadata in a centralized SQLite database as the authoritative source of truth. It enables AI agents to manage complex project states through entity-relationship modeling and can generate human-readable markdown views on demand.

ytmcp

Enables AI assistants to fetch YouTube video transcripts with precise timestamps, multi-language support, and time-range filtering.

Model Context Protocol (MCP) MSPaint App Automation

Okay, this is a more complex request involving inter-process communication (MCP), mathematical problem solving, and integration with MSPaint. Here's a conceptual outline and a simplified Python example to illustrate the core ideas. Keep in mind that a fully robust solution would require significantly more code and error handling. **Conceptual Outline** 1. **MCP Server (Python):** * Listens for incoming connections on a specific port. * Receives a mathematical problem (as a string) from the client. * Parses the problem. * Solves the problem. * Generates a solution string (including steps). * Sends the solution string back to the client. 2. **MCP Client (Python):** * Connects to the MCP server. * Prompts the user to enter a math problem. * Sends the problem to the server. * Receives the solution from the server. * Creates a temporary image file (e.g., using PIL/Pillow). * Draws the solution text onto the image. * Saves the image. * Opens the image in MSPaint using `os.system` or `subprocess`. **Simplified Python Example (Illustrative)** ```python # server.py import socket import threading import ast import traceback HOST = '127.0.0.1' # Standard loopback interface address (localhost) PORT = 65432 # Port to listen on (non-privileged ports are > 1023) def solve_problem(problem): """ A very basic problem solver. Expand this significantly! """ try: # WARNING: Using eval() is DANGEROUS with untrusted input. # This is ONLY for demonstration. Use a proper math parser. result = eval(problem) solution = f"Problem: {problem}\nSolution: {result}" return solution except Exception as e: return f"Error solving problem: {e}\n{traceback.format_exc()}" def handle_client(conn, addr): print(f"Connected by {addr}") with conn: while True: data = conn.recv(1024) if not data: break problem = data.decode() print(f"Received problem: {problem}") solution = solve_problem(problem) conn.sendall(solution.encode()) print(f"Sent solution") def server_main(): with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.bind((HOST, PORT)) s.listen() print(f"Server listening on {HOST}:{PORT}") while True: conn, addr = s.accept() thread = threading.Thread(target=handle_client, args=(conn, addr)) thread.start() if __name__ == "__main__": server_main() ``` ```python # client.py import socket import os import subprocess from PIL import Image, ImageDraw, ImageFont HOST = '127.0.0.1' # The server's hostname or IP address PORT = 65432 # The port used by the server IMAGE_FILE = "solution.png" # Name of the image file def create_image(text, filename): """Creates an image with the given text.""" img = Image.new('RGB', (800, 600), color='white') # Adjust size as needed d = ImageDraw.Draw(img) font = ImageFont.truetype("arial.ttf", 20) # Or another font you have d.text((10, 10), text, fill='black', font=font) img.save(filename) def client_main(): with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.connect((HOST, PORT)) problem = input("Enter a math problem: ") s.sendall(problem.encode()) data = s.recv(4096) # Increase buffer size if needed solution = data.decode() print(f"Received solution:\n{solution}") create_image(solution, IMAGE_FILE) # Open MSPaint (Windows-specific) try: #os.system(f"mspaint {IMAGE_FILE}") # simpler but less robust subprocess.run(["mspaint", IMAGE_FILE]) # more robust except FileNotFoundError: print("MSPaint not found. Make sure it's in your PATH.") except Exception as e: print(f"Error opening MSPaint: {e}") if __name__ == "__main__": client_main() ``` **Key Improvements and Explanations** * **Error Handling:** Includes `try...except` blocks to catch potential errors during problem solving, image creation, and MSPaint execution. The server also includes a traceback to help debug server-side errors. * **Image Creation (PIL/Pillow):** Uses the Pillow library to create an image and draw the solution text onto it. You'll need to install Pillow: `pip install Pillow`. You'll also need to specify a font file that exists on your system (e.g., "arial.ttf"). * **MSPaint Integration:** Uses `subprocess.run(["mspaint", IMAGE_FILE])` to open the image in MSPaint. This is generally more robust than `os.system`. It also includes a check to see if MSPaint is found. * **Encoding/Decoding:** Explicitly encodes and decodes strings when sending data over the socket. * **Threading (Server):** The server now uses threads to handle multiple client connections concurrently. * **`solve_problem` function:** This is now a function, making the code more organized. **IMPORTANT:** The `eval()` function is extremely dangerous with untrusted input. See the warnings below. * **Buffer Size:** Increased the receive buffer size on the client to 4096 bytes. Adjust as needed based on the expected size of the solution string. **How to Run** 1. **Save:** Save the code as `server.py` and `client.py`. 2. **Install Pillow:** `pip install Pillow` 3. **Run the Server:** Open a terminal and run `python server.py`. 4. **Run the Client:** Open another terminal and run `python client.py`. 5. **Enter a Problem:** The client will prompt you to enter a math problem (e.g., `2 + 2`). 6. **MSPaint:** The client will create an image with the solution and attempt to open it in MSPaint. **Important Considerations and Next Steps** * **Security (VERY IMPORTANT):** **DO NOT USE `eval()` IN PRODUCTION CODE!** It is extremely vulnerable to code injection if the input is not carefully sanitized. Use a safe math parsing library like `ast.literal_eval()` (for very simple expressions) or a more robust library like `sympy`. `ast.literal_eval()` only supports basic Python literals (strings, numbers, tuples, lists, dicts, booleans, `None`). `sympy` is a full-featured symbolic mathematics library. ```python # Example using ast.literal_eval (SAFER for simple expressions) import ast def solve_problem_safe(problem): try: result = ast.literal_eval(problem) # Safer than eval() solution = f"Problem: {problem}\nSolution: {result}" return solution except (ValueError, SyntaxError) as e: return f"Error: Invalid expression: {e}" # Example using sympy (for more complex math) # import sympy # from sympy.parsing.mathematica import parse_mathematica # if you want to parse mathematica syntax # def solve_problem_sympy(problem): # try: # #parsed_expr = sympy.parsing.mathematica.parse_mathematica(problem) # if using mathematica syntax # parsed_expr = sympy.sympify(problem) # sympy's default parser # result = sympy.simplify(parsed_expr) # solution = f"Problem: {problem}\nSolution: {result}" # return solution # except Exception as e: # return f"Error: {e}" ``` * **Error Handling:** Add more comprehensive error handling to both the client and server. Handle socket errors, file I/O errors, and MSPaint errors gracefully. * **Problem Parsing:** Implement a more sophisticated problem parser. Consider using a library like `sympy` to handle a wider range of mathematical expressions. * **Solution Formatting:** Improve the formatting of the solution text in the image. Use different fonts, colors, and layout techniques to make it more readable. * **User Interface:** Consider using a GUI library like Tkinter, PyQt, or Kivy to create a more user-friendly interface for the client. * **MCP Protocol:** Define a more formal MCP protocol for communication between the client and server. This could involve defining message types, error codes, and data formats. Consider using JSON or Protocol Buffers for serialization. * **Platform Independence:** The MSPaint integration is Windows-specific. To make the client platform-independent, you'll need to use a different image viewer or editor that is available on other operating systems. You could also allow the user to specify the image viewer to use. * **Security (Again):** If this is going to be used in any kind of networked environment, think very carefully about security. Authentication, authorization, and encryption may be necessary. This expanded example provides a much more solid foundation for building your MCP math problem solver. Remember to prioritize security and error handling as you add more features. Good luck!

MCP Firebird

Um servidor que implementa o Protocolo de Contexto de Modelo (MCP) da Anthropic para bancos de dados Firebird SQL, permitindo que Claude e outros LLMs acessem, analisem e manipulem dados em bancos de dados Firebird de forma segura através de linguagem natural.

claude-memory

Cross-machine memory system for Claude Code that records sessions as searchable markdown, syncs across machines via Git, and exposes full-text search, semantic search, session summarization, and a knowledge graph through an MCP server.

readypermit-mcp

AI-powered property intelligence for instant zoning analysis, buildability assessments, ADU eligibility, flood risk, and development feasibility reports for any US address.

IoT Device Management MCP Server

Enables registration, monitoring, and control of IoT devices via AI agents, with local storage and no cloud API key required.

CloakMCP

An MCP server that provides LLMs with stealth browser automation capabilities via CloakBrowser to bypass bot detection services like Cloudflare and reCAPTCHA. It supports full page interaction, content extraction, and human-like behavior through 30 specialized tools.

paraph-mcp

MCP server for the Paraph e-signature API that enables AI tools to fill PDF forms and manage electronic signing workflows. It provides tools for template management, document filling, sending signing requests, and tracking signing progress.

flux7-mesh

Guardrail sidecar proxy between AI agents and their MCP/REST/CLI tools. Policy engine, human approval gates, time-limited grants, rate limiting, and OTEL tracing. One Go binary, one YAML config, fail-closed by default.

Amazon Product Search MCP

Enables AI-powered Amazon product searches and recommendations by integrating the Amazon API with Hugging Face models. It allows users to filter products by price and specific features to receive tailored shopping suggestions.

Domain Availability Checker MCP

Domain Availability Checker MCP

Red-team-mcp

An MCP server for red teaming that enables AI agents to perform port scanning, vulnerability scanning, SSH operations, and Metasploit exploitation through a unified interface.

SIN-Code MCP Server Builder Skill

Scaffolds new MCP servers for the OpenSIN-Code ecosystem with templates for Python, Node, Go; provides tools to add tools, test, validate, register, publish, and audit servers.

Kolosal Vision MCP

Provides AI-powered image analysis and OCR capabilities using the Kolosal Vision API. Supports analyzing images from URLs, local files, or base64 data with natural language queries for object detection, scene description, text extraction, and visual assessment.

TOTP MCP Server

Generates time-based one-time password (TOTP) 2FA codes for configured accounts, enabling Claude to automate workflows requiring two-factor authentication.

touchdesigner-mcp

An MCP server for TouchDesigner that lets you control TouchDesigner with Claude

personality-test-mcp

Enables AI models to administer personality tests, score responses, and provide personality type assessments, with optional integration with Ollama for personalized AI interactions.

ComfyUI MCP

MCP server + Claude Code plugin for ComfyUI: execute workflows, generate images, visualize pipelines as Mermaid diagrams, compose/validate workflows, manage and download models, control VRAM, and explore custom nodes. 36 tools, cross-platform, installs via npx -y comfyui-mcp.

Purple Flea Wallet

Non-custodial HD wallet API for AI agents. Generate wallets on 6 chains (ETH, Base, SOL, BTC, TRX, XMR), check balances, send crypto, and swap cross-chain via Wagyu aggregator. 10% referral commissions.

Dovetail MCP Server

Enables AI tools to connect to the Dovetail API for accessing customer insights and research data.

MCP Memory

An MCP server that enables clients like Cursor, Claude, and Windsurf to remember user information and preferences across conversations using vector search technology.