Discover Awesome MCP Servers

mcp-starter-kit

A scaffolding toolkit to generate clean architecture MCP servers with tool scaffolding and function inspection.

Freshservice MCP server

Freshservice MCP server

mcp-postgres

Enables AI agents to interact with PostgreSQL databases through schema intelligence, query execution, and DBA tooling including index analysis and health monitoring. Features configurable access levels and audit logging for secure database operations.

narajangteo-searcher

Enables users to search and analyze Korean public procurement IT bid announcements, including full bid opening results, through natural language conversation with Claude.

Chiasmus

MCP server that gives LLMs access to formal verification via Z3 and SWI-Prolog, plus tree-sitter-based source code analysis. Translates natural language problems into formal logic using a template-based pipeline, verifies results with mathematical certainty, and analyzes call graphs for reachability, dead code, and impact analysis.

MCP-Edge

Enables cloud LLM agents to discover and invoke physical hardware on edge and IoT devices through standard MCP tools, bridging constrained device channels like UART, BLE, and Wi-Fi.

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!

stock-mcp

An MCP server that exposes DSA's 问股 (Agent Chat / ask-stock) capability as a cross-client tool, allowing users to ask natural-language stock questions and list available strategy skills.

kubernetes-mcp-server

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

xero-oauth-mcp-server

Enables natural language interaction with Xero accounting data, managing contacts, invoices, and accounts across multiple organisations via OAuth2.

ETSI Standards Connector

Fetches, parses, and summarizes ETSI telecommunications and media standards documents, enabling Claude to autonomously look up and ingest standards mid-conversation for answering questions, generating conformant code, or writing XML.

ClickUp MCP Server

Un servidor de Protocolo de Contexto de Modelo que permite a los agentes de IA interactuar con los espacios de trabajo de ClickUp, permitiendo la creación, gestión y organización del espacio de trabajo a través de comandos en lenguaje natural.

BlenderMCP

BlenderMCP integrates Claude AI with Blender via the Model Context Protocol to enable prompt-assisted 3D modeling, scene creation, and professional retopology workflows. It allows users to manipulate objects, apply materials, and execute Python scripts directly within the Blender environment through natural language.

azure-devops-mcp

Multi-user wrapper around Microsoft's Azure DevOps MCP server, enabling AI agents to authenticate per-user and interact with Azure DevOps tools via isolated PATs.

Random Value MCP Server

Generates random integers within a specified range and random alphanumeric strings of specified length through MCP protocol integration.

TaskPad

A Windows system-tray task manager with MCP server integration, enabling Claude Code, Claude Desktop, and claude.ai to read and write tasks via stdio or SSE.

notion-mcp

MCP server for the Notion API with tools for managing pages, databases, content, and workspace resources. Generated with MCPForge. Sensitive operations can be protected with permissions, audit logs, and approval workflows.

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.

Domestique

Integrates with Intervals.icu, Whoop, and TrainerRoad to provide unified access to fitness data, including completed workouts, recovery metrics, planned training, and performance trends across all sports.

WordPress MCP Integration

Este servidor MCP te permite automatizar interacciones con Wordpress.

LSD MCP Server

An MCP server that connects language models to the LSD database, enabling web data extraction, research capabilities, and custom 'trips' for extending functionality through the internetdata SDK.

R-Shell

MCP server enabling AI assistants to securely operate remote servers via persistent SSH sessions, with tools for command execution, file transfer, directory listing, and system monitoring.

ticktick-cli

MCP server for TickTick task management. Enables AI assistants to create, update, list, search, and complete tasks via natural language.

Hong Kong Food Data MCP Server

Provides access to Hong Kong food data, including wholesale food prices, through a FastMCP interface.

sessions-mcp

MCP server for sharing, searching, and pulling AI coding-agent sessions (Claude Code and Codex) directly from the agent, with automatic capture and link-based sharing.

MCP Platform

A reusable runtime infrastructure for hosting Model Context Protocol servers and tool registries over HTTP. It provides built-in validation, authentication, and logging to simplify the deployment of AI-powered workflows.

agda-mcp-server

A stateful Model Context Protocol server for interactive Agda proof development, enabling persistent sessions with goal-aware proof actions.

hardline-mcp

Enables local AI coding agents to message each other on one machine using a durable SQLite mailbox and live-ask tools.

remote-mcp-server-authless

Enables deploying a remote MCP server on Cloudflare Workers without authentication, with customizable tools for use with AI Playground or Claude Desktop.

acsearch-mcp

MCP server for acsearch.info, enabling search, retrieval, price history, and comparable analysis of ancient coin auction data from 16M+ lots across 475 auction houses. Requires a Premium account.