Discover Awesome MCP Servers

AI Consultant MCP Server

Enables AI agents to consult with multiple AI models (GPT, Gemini, Grok, etc.) through OpenRouter with intelligent auto-selection, conversation history, and caching. Allows your AI assistant to seek expert opinions from specialized models for different tasks like coding, analysis, or general questions.

TrackingTime MCP

Connects AI assistants to TrackingTime for querying time entries, projects, tasks, customers, and team data using natural language.

cv-forge-mcp

MCP server for generating professional ATS-friendly CVs as PDF/DOCX from AI conversations. Auto-manages a Docker container with a visual editor for layout customization.

mcp-agentdocs

Fresh, source-verified docs for building MCP servers and Claude agents, served to your AI coding agent over MCP. Each document is stamped with its source URL and last-verified date.

Obsidian MCP Learning System

A local MCP server that transforms an Obsidian vault into a structured learning interface through tools for concept extraction and gap analysis. It enables AI agents to generate study plans and align note-taking with implementation projects for a more cohesive learning workflow.

Bolna MCP Server

Manage voice AI agents, make calls, run campaigns, and control phone numbers through natural language.

Clerk MCP Server Template

A production-ready template for building Model Context Protocol servers with Clerk authentication on Cloudflare Workers, allowing AI assistants to securely access user data and business logic in Clerk-authenticated applications.

mcp_repo9756c6c7-ee07-4f3a-ada4-f6e2705daa02

Este es un repositorio de prueba creado por un script de prueba del Servidor MCP para GitHub.

kubeview-mcp

Read-only MCP server for safe Kubernetes inspection, diagnosis, and debugging. Supports Kubernetes core, Helm, Argo Workflows, and Argo CD.

Roundtable

A multi-role AI discussion system that enables users to manage diverse AI personas for collaborative debate and consensus-driven decision-making. It provides tools for role configuration, automated meeting facilitation, and the generation of formatted meeting minutes via the MCP protocol.

Materials Project Platform MCP Server

The Materials Project MCP Server is server that provides programmatic access to the Materials Project database. It enables LLMs, to search, analyze, and retrieve up to date materials science data.

ApiPost MCP

A server that enables management of ApiPost API documentation and team collaboration through the Model Context Protocol, supporting complete interface management directly from compatible editors.

legends-mcp

Your personal council of tech titans, investing legends, and crypto builders. 36 personas. Zero API keys. One npx command.

Industrial MCP Server

Enables AI assistants to monitor and interact with industrial systems, providing real-time system health monitoring, operational data analytics, and equipment maintenance tracking. Built with Next.js and designed for industrial automation environments.

WebClone MCP Server

Enables AI agents to clone entire websites, download files, manage authentication sessions, and analyze site information with support for JavaScript-heavy SPAs and dynamic content.

Swagger/Postman MCP Server

Enables AI agents to dynamically discover and interact with APIs through Swagger/OpenAPI specifications and Postman collections using a strategic four-tool approach. It streamlines API integration by providing universal tools for endpoint discovery, detailed request information, and authenticated execution.

lunchmoney-mcp

A comprehensive MCP server that enables AI assistants to manage Lunch Money finances through 37 tools for transactions, budgets, and accounts. It supports both local stdio and remote HTTP transport modes with secure, encrypted credential storage.

MCP-Server

Una implementación de un Protocolo de Contexto de Modelo que permite a los modelos de lenguaje grandes llamar a herramientas externas (como pronósticos del tiempo e información de GitHub) a través de un protocolo estructurado, con visualización del proceso de razonamiento del modelo.

Websearch MCP Server

Enables web searching via DuckDuckGo and page fetching with automatic HTML-to-Markdown conversion to reduce LLM token usage by approximately 60%. It provides tools for search, content extraction, and combined operations without requiring any external API keys.

IDA-doc-hint-mcp

Servidor MCP (más o menos) lector de documentación de IDA

WordPress Standalone MCP Server

A Model Context Protocol server that automatically discovers WordPress REST API endpoints and creates individual tools for each endpoint, enabling natural language management of WordPress sites.

MCP Server

A modular Model Control Protocol server that provides tools for GitHub repository analysis, calculations, weather, time, and command execution via HTTP or stdio.

Shopify MCP Pro

Shopify MCP server with working analytics (ShopifyQL), auto-refresh auth, and Shopify API 2026-04. Fixed broken tools from other packages real sales reports, no silent token expiry, no runtime crashes

youtube-gemini-mcp

Enables conversational analysis of YouTube videos using Gemini 2.5 Pro, supporting multi-turn sessions, direct URL processing, and local video uploads.

Jira MCP Server

Provides read-only issue and project management tools for Jira Server/DC, enabling querying issues, projects, and assignments via natural language.

macos-clipboard-mcp

Provides MCP tools to copy text to and paste text or images from the macOS clipboard using AppleScript.

yfinance-mcp

Okay, here's a basic outline and code snippets to get you started with a Python MCP (Message Control Protocol) server for yfinance. This is a simplified example and would need further development for production use. **Concept:** The idea is to create a server that listens for requests (likely stock tickers) over a network connection using MCP. Upon receiving a request, the server uses `yfinance` to fetch the data and sends the data back to the client. **Important Considerations:** * **MCP Implementation:** MCP is a relatively old protocol. You'll likely need to find a Python library that supports it, or implement the core parts yourself. If you're starting from scratch, consider using a more modern protocol like TCP with a simple text-based or JSON-based message format. This will be much easier to implement and debug. * **Error Handling:** Robust error handling is crucial. Handle network errors, `yfinance` errors (e.g., invalid ticker), and data serialization errors. * **Security:** If this server will be exposed to a network, consider security implications. MCP itself doesn't provide security. You might need to add encryption or authentication. * **Data Format:** Decide on the format for sending data back to the client (e.g., JSON, CSV, a custom format). JSON is generally a good choice for its flexibility and ease of parsing. * **Concurrency:** For handling multiple client requests simultaneously, you'll need to use threading, asynchronous programming (asyncio), or multiprocessing. * **Rate Limiting:** `yfinance` might have rate limits. Implement a mechanism to avoid exceeding them. **Simplified Example (using TCP instead of MCP for simplicity):** This example uses TCP sockets because a full MCP implementation is beyond the scope of a quick response. It demonstrates the core logic of fetching data from `yfinance` and sending it back to a client. You would need to adapt this to use MCP if that's a strict requirement. ```python import socket import yfinance as yf import json # Server configuration HOST = '127.0.0.1' # Standard loopback interface address (localhost) PORT = 65432 # Port to listen on (non-privileged ports are > 1023) def fetch_stock_data(ticker): """Fetches stock data from yfinance and returns it as a JSON string.""" try: stock = yf.Ticker(ticker) data = stock.history(period="1d") # Get 1 day of data if data.empty: return json.dumps({"error": f"No data found for ticker: {ticker}"}) # Convert the DataFrame to a dictionary suitable for JSON serialization data_dict = data.to_dict(orient="index") return json.dumps(data_dict) # Serialize to JSON except Exception as e: return json.dumps({"error": str(e)}) def handle_client(conn, addr): """Handles a single client connection.""" print(f"Connected by {addr}") while True: data = conn.recv(1024) # Receive data from the client if not data: break # Client disconnected ticker = data.decode().strip() # Decode the ticker symbol print(f"Received ticker: {ticker}") stock_data_json = fetch_stock_data(ticker) # Fetch data and serialize to JSON conn.sendall(stock_data_json.encode()) # Send the JSON data back conn.close() print(f"Connection closed with {addr}") def main(): """Main server function.""" 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() # In a real application, you'd likely want to use threading or asyncio # to handle multiple clients concurrently. For simplicity, this example # handles one client at a time. handle_client(conn, addr) if __name__ == "__main__": main() ``` **Explanation:** 1. **Imports:** Imports necessary libraries (`socket`, `yfinance`, `json`). 2. **`fetch_stock_data(ticker)`:** * Takes a stock ticker as input. * Uses `yfinance` to fetch historical data (1 day in this example). You can adjust the `period` parameter. * Handles potential errors (e.g., invalid ticker). * Converts the `yfinance` DataFrame to a dictionary using `to_dict(orient="index")`. This creates a dictionary where the keys are the dates (index) and the values are dictionaries of the data for that date. * Serializes the dictionary to a JSON string using `json.dumps()`. * Returns the JSON string. 3. **`handle_client(conn, addr)`:** * Handles communication with a single client. * Receives data (the ticker symbol) from the client. * Calls `fetch_stock_data()` to get the data. * Sends the JSON data back to the client. * Closes the connection. 4. **`main()`:** * Creates a TCP socket. * Binds the socket to the specified host and port. * Listens for incoming connections. * Accepts a connection from a client. * Calls `handle_client()` to handle the client's requests. * **Important:** This example handles one client at a time. For a real-world server, you'd need to use threading or `asyncio` to handle multiple clients concurrently. **Client Example (TCP):** ```python import socket HOST = '127.0.0.1' # The server's hostname or IP address PORT = 65432 # The port used by the server with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.connect((HOST, PORT)) ticker = "AAPL" # Example ticker s.sendall(ticker.encode()) data = s.recv(4096) # Receive up to 4096 bytes print('Received:', data.decode()) ``` **How to Run:** 1. Save the server code as `yfinance_server.py`. 2. Save the client code as `yfinance_client.py`. 3. Run the server: `python yfinance_server.py` 4. Run the client: `python yfinance_client.py` **To Adapt to MCP:** 1. **Find an MCP Library:** Search for a Python library that supports MCP. If you can't find one, you'll need to implement the MCP protocol yourself (which is a significant undertaking). 2. **Replace Socket Code:** Replace the `socket` code in the server and client with the MCP library's functions for creating connections, sending messages, and receiving messages. 3. **MCP Message Formatting:** Ensure that the messages you send and receive conform to the MCP protocol's specifications. This will involve encoding and decoding the data according to MCP's rules. **Example using `socketserver` for multithreading (TCP):** This is a more robust example that uses the `socketserver` module to handle multiple clients concurrently using threads. It's still using TCP, but it demonstrates how to handle multiple requests. ```python import socketserver import yfinance as yf import json class YFinanceHandler(socketserver.BaseRequestHandler): """ The request handler class for our server. It is instantiated once per connection to the server, and must override the handle() method to implement communication to the client. """ def handle(self): # self.request is the TCP socket connected to the client self.data = self.request.recv(1024).strip() ticker = self.data.decode() print(f"{self.client_address[0]} wrote: {ticker}") stock_data_json = self.fetch_stock_data(ticker) self.request.sendall(stock_data_json.encode()) def fetch_stock_data(self, ticker): """Fetches stock data from yfinance and returns it as a JSON string.""" try: stock = yf.Ticker(ticker) data = stock.history(period="1d") # Get 1 day of data if data.empty: return json.dumps({"error": f"No data found for ticker: {ticker}"}) # Convert the DataFrame to a dictionary suitable for JSON serialization data_dict = data.to_dict(orient="index") return json.dumps(data_dict) # Serialize to JSON except Exception as e: return json.dumps({"error": str(e)}) class ThreadedTCPServer(socketserver.ThreadingMixIn, socketserver.TCPServer): pass if __name__ == "__main__": HOST, PORT = "localhost", 65432 server = ThreadedTCPServer((HOST, PORT), YFinanceHandler) with server: print(f"Server listening on {HOST}:{PORT}") # Start a thread with the server -- that thread will then start one # more thread for each request server.serve_forever() ``` **Key Improvements in the `socketserver` Example:** * **Multithreading:** The `ThreadedTCPServer` allows the server to handle multiple client requests concurrently. Each client connection is handled in a separate thread. * **`socketserver` Module:** Uses the `socketserver` module, which simplifies the creation of network servers. * **Request Handler:** The `YFinanceHandler` class encapsulates the logic for handling a single client request. This makes the code more organized and easier to maintain. **Remember to install yfinance:** ```bash pip install yfinance ``` This comprehensive response provides a starting point for building your Python MCP server for `yfinance`. Remember to adapt the code to use MCP if that's a strict requirement, and to add proper error handling, security, and concurrency for a production environment. Good luck!

Hive Civilization Server

Here's the description to paste into Glama when you submit: Hive Civilization MCP Server — production-ready MCP server (2024-11-05, Streamable-HTTP) wrapping the Hive autonomous agent economy. 6 tools: register sovereign W3C DIDs, settle payments across 4 rails (Base USDC · Aleo USDCx · Aleo USAd · Aleo native), create HAHS hiring contracts, verify W3C Verifiable Credentials, list open bounties,

kubernetes-mcp-server

A powerful and flexible Kubernetes MCP server implementation with support for OpenShift.