Discover Awesome MCP Servers

mteam-mcp

MCP server for M-Team that enables seed search, detail viewing, and .torrent file download through standard stdio MCP, designed for Hermes Agent.

Dataverse MCP Server

Enables direct interaction with Microsoft Dataverse from Claude Desktop, supporting full CRUD, bulk operations, FetchXML queries, actions, and metadata discovery.

now-mcp

Provides the current date and time, enabling Claude to be time-aware. Supports timezone resolution via argument, URL parameter, or geolocation.

tavily_mcp

MCP server for Tavily search and web data tools, enabling search, extract, crawl, and map operations through a simple HTTP or stdio interface.

@morphixai/mcp-server

MCP server enabling AI agents to interact with workplace tools like GitHub, GitLab, Jira, Notion, and more via the Model Context Protocol.

shieldly-mcp

Enables AI assistants to analyze AWS IAM policies and CloudFormation templates for security risks.

codasms-mcp

Enables AI agents to purchase phone numbers and retrieve one-time SMS/OTP verification codes via the CODASMS API, with support for 700+ services and 180+ countries including automatic refunds if no code arrives.

Hebbrix MCP Server

Provides long-term memory and a temporal knowledge graph for AI agents, enabling persistent memory and reasoning across sessions.

Gitignore MCP Tool

An MCP server that generates project-specific .gitignore files and lists available templates using the gitignore.io API. It allows users to streamline project configuration by creating customized ignore files for various programming languages and development environments.

sf-mcp

MCP server for Salesforce that exposes CLI, REST, Connect, Data 360, Bulk 2.0, and Einstein Models APIs as tools for any MCP-compatible client to manage orgs, data, and metadata.

Decker

Deterministic market-state engine for trading agents — zero LLM in the signal path. 8 tools: structural market state & phase, action gate (GO/WATCH/HOLD), entry/target/invalidation coordinates, bar-by-bar state timeline, composed view cards, and pre-trade intent validation. Every output traces to a bar-stamped ledger with a public daily self-scoring track record.

MCPServe

A simple MCP Server with shell execution capabilities that can be run locally with Ngrok tunneling or hosted in an Ubuntu 24 Docker container.

wecom-msg-audit-mcp

Enables AI agents to securely access and search enterprise WeChat (WeCom) chat records with full decryption and auditing, supporting message retrieval, decryption, local storage, and querying via MCP tools.

SpotifyScraper MCP Server

Enables AI agents to access public Spotify data (tracks, albums, artists, playlists, podcasts) without an API key, including lyrics and podcast transcripts with optional login.

intervals-mcp

Local MCP server for analyzing Intervals.icu accounts, creating AI-assisted training plans, and applying managed drafts to the calendar after explicit confirmation.

memnant

Persistent memory MCP server that remembers decisions and context across coding sessions, automatically logging and surfacing relevant knowledge as you work.

Azure DevOps MCP Server

Enables AI agents to query and interact with Azure DevOps data, including work items, projects, ticket statistics, and backlog information through natural language commands.

construction-mcp-server

Provides read-only MCP tools to query building construction approval lifecycle data, covering project discovery, bidding, contracts, drawing review, permits, and completion records.

Apple Music MCP Server

Integrates Apple Music with MCP clients to search the global catalog, manage personal playlists, and access library data. It enables users to perform actions like creating playlists, adding tracks, and viewing recommendations through natural language commands.

MCPHOST-SERVER

Here are a few options for an MCP (Multi-Cloud Provider) server that bridges Ollama, OpenAI, and Anthropic, along with considerations for each: **Conceptual Overview** The core idea is to create a single API endpoint that can route requests to different LLMs (Ollama, OpenAI, Anthropic) based on configuration. This allows you to: * **Abstract away the specific API details** of each provider. * **Easily switch between providers** without changing your client code. * **Implement load balancing or failover** across providers. * **Potentially optimize costs** by using the cheapest available provider for a given task. * **Enforce rate limits and authentication** in a centralized location. **Possible Implementations** Here are a few ways you could build this, ranging from simpler to more complex: 1. **Simple Proxy/Router (Python with Flask/FastAPI):** * **How it works:** A lightweight web server that receives requests, inspects them (e.g., based on a `model` parameter), and forwards them to the appropriate LLM API. * **Pros:** Easy to set up, good for basic routing. * **Cons:** Requires you to handle authentication, rate limiting, and error handling yourself. Less scalable for high-volume traffic. * **Example (Conceptual - Flask):** ```python from flask import Flask, request, jsonify import requests import os app = Flask(__name__) # Configuration (ideally from environment variables) OLLAMA_URL = os.environ.get("OLLAMA_URL", "http://localhost:11434") OPENAI_API_KEY = os.environ.get("OPENAI_API_KEY") ANTHROPIC_API_KEY = os.environ.get("ANTHROPIC_API_KEY") @app.route("/generate", methods=["POST"]) def generate(): data = request.get_json() model = data.get("model") prompt = data.get("prompt") if not model or not prompt: return jsonify({"error": "Missing model or prompt"}), 400 try: if model == "ollama": response = requests.post(f"{OLLAMA_URL}/api/generate", json={"prompt": prompt, "model": "llama2"}) # Adjust model name as needed response.raise_for_status() # Raise HTTPError for bad responses (4xx or 5xx) return jsonify(response.json()) # Or parse the streaming response elif model == "openai": headers = {"Authorization": f"Bearer {OPENAI_API_KEY}"} response = requests.post("https://api.openai.com/v1/completions", headers=headers, json={"model": "text-davinci-003", "prompt": prompt, "max_tokens": 150}) # Adjust model and parameters response.raise_for_status() return jsonify(response.json()) elif model == "anthropic": headers = {"x-api-key": ANTHROPIC_API_KEY, "Content-Type": "application/json"} response = requests.post("https://api.anthropic.com/v1/complete", headers=headers, json={"prompt": f"\n\nHuman: {prompt}\n\nAssistant:", "model": "claude-v1", "max_tokens_to_sample": 200}) # Adjust model and parameters response.raise_for_status() return jsonify(response.json()) else: return jsonify({"error": "Invalid model"}), 400 except requests.exceptions.RequestException as e: print(f"Error communicating with LLM: {e}") return jsonify({"error": f"LLM error: {e}"}), 500 except Exception as e: print(f"Unexpected error: {e}") return jsonify({"error": f"Server error: {e}"}), 500 if __name__ == "__main__": app.run(debug=True, host="0.0.0.0", port=5000) ``` * **Key improvements for production:** * **Error Handling:** More robust error handling, logging, and potentially retry mechanisms. * **Configuration:** Load API keys and endpoint URLs from environment variables or a configuration file. Don't hardcode them! * **Authentication:** Implement authentication (e.g., API keys, JWT) to protect your endpoint. * **Rate Limiting:** Implement rate limiting to prevent abuse and stay within API limits. Libraries like `Flask-Limiter` can help. * **Asynchronous Requests:** Use `asyncio` and `aiohttp` for asynchronous requests to the LLM APIs to improve performance. * **Streaming:** Handle streaming responses from the LLMs (especially important for Ollama). Flask's `stream_with_context` can be used. * **Logging:** Comprehensive logging for debugging and monitoring. * **Monitoring:** Metrics collection (e.g., using Prometheus) to track performance and errors. * **Deployment:** Deploy using a production-ready WSGI server like Gunicorn or uWSGI. 2. **More Advanced: API Gateway (Kong, Tyk, Traefik):** * **How it works:** Use a dedicated API gateway to handle routing, authentication, rate limiting, and other cross-cutting concerns. The gateway sits in front of your backend service (which still handles the LLM API calls). * **Pros:** Scalable, feature-rich, handles many common API management tasks. * **Cons:** More complex to set up and configure. Adds another layer of infrastructure. * **Example:** You would configure Kong (or your chosen gateway) to route requests based on the `model` parameter to different backend services (or even directly to the LLM APIs). You would use Kong's plugins for authentication, rate limiting, etc. The backend service would be similar to the Flask/FastAPI example above, but it would focus solely on making the LLM API calls. 3. **Kubernetes Ingress with Routing:** * **How it works:** If you're running in Kubernetes, you can use an Ingress controller (e.g., Nginx Ingress Controller, Traefik) to route requests based on path or host to different services. Each service would be responsible for handling a specific LLM. * **Pros:** Well-integrated with Kubernetes, scalable, good for microservices architectures. * **Cons:** Requires Kubernetes knowledge. * **Example:** You might have three services: `ollama-service`, `openai-service`, and `anthropic-service`. The Ingress controller would route requests to `/ollama/*` to `ollama-service`, `/openai/*` to `openai-service`, and so on. 4. **Serverless Functions (AWS Lambda, Google Cloud Functions, Azure Functions):** * **How it works:** Create serverless functions that handle the LLM API calls. Use an API Gateway (e.g., AWS API Gateway) to route requests to the appropriate function based on the `model` parameter. * **Pros:** Scalable, pay-per-use, no server management. * **Cons:** Cold starts can be an issue. More complex to debug. Potential vendor lock-in. * **Example:** You would have three functions: `ollama-function`, `openai-function`, and `anthropic-function`. The API Gateway would route requests to `/ollama` to `ollama-function`, `/openai` to `openai-function`, and so on. **Key Considerations:** * **Authentication:** How will you authenticate users or applications that are calling your MCP server? API keys, JWTs, OAuth? * **Authorization:** Will you need to control which users or applications can access which LLMs? * **Rate Limiting:** Implement rate limiting to prevent abuse and stay within the API limits of the LLMs. Consider different rate limits for different LLMs. * **Error Handling:** Handle errors gracefully and provide informative error messages to the client. Implement retry mechanisms for transient errors. * **Logging and Monitoring:** Log all requests and responses for debugging and auditing purposes. Monitor the performance of your MCP server and the LLM APIs. * **Configuration:** Use environment variables or a configuration file to store API keys, endpoint URLs, and other configuration parameters. This makes it easier to deploy and manage your MCP server. * **Security:** Protect your API keys and other sensitive information. Use HTTPS to encrypt traffic. * **Streaming:** If you need to support streaming responses from the LLMs (especially important for Ollama), you'll need to use a framework that supports streaming (e.g., Flask with `stream_with_context`, FastAPI with streaming responses). * **Cost Optimization:** Consider the cost of each LLM and route requests to the cheapest available LLM for a given task. * **Model Mapping:** You'll need to map the models available in each LLM to a common set of model names that your clients can use. For example, you might map "llama2" in Ollama to "llama-2" in your MCP server's API. * **Input/Output Format:** Standardize the input and output format of your MCP server to make it easier for clients to use. Consider using JSON Schema to define the input and output formats. * **Latency:** Be aware of the latency of each LLM and choose the LLM that provides the best performance for your needs. * **Ollama Specifics:** Ollama is often run locally or in a private network. Make sure your MCP server can access the Ollama instance. Ollama's API is also slightly different from OpenAI and Anthropic, so you'll need to handle the differences in your code. Ollama often returns streaming responses, so you'll need to handle that appropriately. **Example API Endpoint (Conceptual):** ``` POST /generate { "model": "ollama", // or "openai", or "anthropic" "prompt": "Write a short story about a cat." "max_tokens": 100 // Optional, pass through to the LLM } ``` The MCP server would then route this request to the appropriate LLM API, translate the request if necessary, and return the response to the client. **In summary:** The best approach depends on your specific requirements and infrastructure. Start with a simple proxy/router (Flask/FastAPI) and then move to a more advanced solution (API Gateway, Kubernetes Ingress, Serverless Functions) as your needs grow. Remember to focus on authentication, rate limiting, error handling, logging, and monitoring.

Shufersal MCP Server

Provides automated shopping capabilities for the Shufersal website using Puppeteer, enabling LLMs to search products, create shopping lists, and add items to shopping carts.

MCP Router

A cloud-agnostic orchestration server that routes requests to pluggable tool adapters via the MCP protocol, deployable on EKS or AKS without code changes.

freelancer-focus-calendar

An MCP server for freelancers to manage events and tasks with CRUD, calendar views, webhook reminders, and Google Calendar sync.

MCP Code Checker

Enables AI assistants to perform comprehensive code quality checks including pylint, pytest, and mypy analysis on Python projects, with smart prompts for explaining issues and suggesting fixes.

Vulnerable MCP Server

An educational MCP server demonstrating common security vulnerabilities like command injection, path traversal, SQL injection, and XXE attacks. Designed for security training purposes only, not for production use.

MCP Support Agent

Enables ticket management through a REST API and support document search via a local vector database, powered by Ollama and LanceDB.

Proof MCP

An MCP server that exposes a Proof workspace to MCP clients, enabling tools for reading/writing concepts, managing ideas and projects, running ideation operators, and more, with live sync and headless authentication.

@wllcyg/yapi-mcp

Enables searching YApi interfaces by keyword and retrieving detailed interface schemas, including request/response, for project-level tokens.

JUCESP: Ficha Cadastral Simplificada

Fetches simplified company registration data from JUCESP (São Paulo state trade board) by CNPJ, NIRE, or company name. Read-only, hosted, no credentials, with pay-per-use prepaid credits.

Spec Workflow MCP

An intelligent MCP server that helps development teams maintain high-quality project documentation by providing an AI-powered workflow for creating comprehensive specifications through requirements, design, and implementation documents.