发现优秀的 MCP 服务器

Travel Assistant MCP

Enables travel search workflows including airport lookup, route comparison, travel timing guidance, and external booking links with commission-eligible links.

Apache Doris MCP Server

Apache Doris 和 VeloDB 的 MCP 服务器

Discord MCP Server

一个 MCP 服务器，它允许 Claude 通过提供发送/读取消息以及通过 Discord API 管理服务器资源的工具来与 Discord 互动。

Arre Ankit_notion Mcp Server

镜子 (jìng zi)

Guild Wars 1 MCP

Read-only MCP server for public Guild Wars 1 sources (wiki, builds, YouTube, Reddit) and optional local install inventory.

nfip-mcp-server

An MCP server that exposes real US flood insurance claims data from FEMA's OpenFEMA API, providing tools for claim lookup, filtered search, aggregate stats, and flood event summaries.

metadata_mcp

Reads and writes metadata across images, audio, video, documents, and text files using ExifTool, mutagen, and inline handlers, supporting bulk operations with glob patterns.

multi-model-companion

Local MCP server that lets Claude Code delegate bounded, read-only tasks to external AI models (Codex, Grok, local OpenAI-compatible servers) via CLIProxyAPI.

mcp-pagure

Enables AI assistants to manage issues, pull requests, and projects on Pagure instances (pagure.io and self-hosted).

Markitdown Universal MCP Server

Provides a standardized interface for interacting with Markitdown's tools and services through a unified API, compatible with MCP-compliant services.

orchard-data-mcp

Pay-per-call MCP server for market data with USDC micro-payments, featuring unique ML market-regime forecasts, news catalyst radar, and a live-verified algorithmic trading track record.

mcp-ripe-stat

Provides IP, ASN, and BGP routing data from RIPE Stat API, enabling whois lookups, network info, AS overview, BGP state, abuse contacts, and geolocation queries.

NEAR MCP

通过 MCP 调用与 NEAR 区块链交互

AetherServe

An operations layer for MCP servers that adds metrics, health checks, rate limiting, structured logging, and lifecycle hooks.

README Generator MCP Server

Enables LLMs to automatically analyze project structures, detect technologies, and generate comprehensive, professional README documentation files with proper formatting, badges, and sections.

Pipedrive MCP Server by CData

This project builds a read-only MCP server. For full read, write, update, delete, and action capabilities and a simplified setup, check out our free CData MCP Server for Pipedrive (beta): https://www.cdata.com/download/download.aspx?sku=KDZK-V&type=beta

Microsoft Graph MCP Server

A Model Context Protocol server that connects to Microsoft Graph API, allowing AI assistants to query and access data from Microsoft Entra ID (formerly Azure Active Directory).

GridStack MCP Server

Provides comprehensive access to GridStack.js functionality for building dynamic dashboard layouts and responsive drag-and-drop grid systems. Includes 26+ tools for widget management, layout control, and serialization with support for React, Vue, and modern CSS frameworks.

MCP AI Infra Real Time Agent

开发了一种基于 MCP 的 AI 基础设施，该基础设施能够为 Claude 和 Cursor 等 AI 客户端提供实时工具执行、结构化知识检索和动态代理交互。

Fabric Marketplace

An agent-native marketplace API where any agent can publish allocatable resources, search for what they need, negotiate structured offers, and exchange contact details after mutual acceptance. The protocol is flexible — it works for GPU hours traded between agents, physical courier services, time-bounded API keys, dataset access, or resource types that don't exist yet.

AutoFYI MCP

Enables safe financial operations on the AutoFYI platform through natural language, including client search, allocation preparation, and invoice management with two-stage confirmation.

YouTube MCP Server

Streamable HTTP MCP server for YouTube that enables video search, channel exploration, playlist browsing, and video detail retrieval via the YouTube Data API.

Aegis

MCP server for a wealth advisory assistant that enables client portfolio lookup, research search, compliance rule checks, and briefing synthesis via auditable agent tools.

mcp-flow

Self-hosted workspace MCP gateway that registers MCP servers, stores secrets encrypted, mints agent keys, and shares a unified tool library across multiple AI harnesses.

nodus-mcp

A thin stdio gateway to Nodus's Streamable HTTP MCP server, exposing a curated allowlist of tools for the Research Workbench. It enables secure, bearer-authenticated interactions with Nodus without graph logic or caching.

proxmox-mcp

A PROXMOX implementation containing 152 tools covering QEMU VMs, LXC, unified guest power, storage admin, cluster/tasks, snapshots, backups (incl. scheduled jobs), migration, HA, firewall (incl. IPSet CIDRs), access control, replication, SDN (read), ACME (read), pools, and console tickets.

Email Processing MCP Server

This is a complex task involving several steps and technologies. Here's a breakdown of the process and a conceptual outline of how you might implement it, along with considerations for each step: **1. Outlook Email Extraction and Date Filtering:** * **Technology:** Python with libraries like `win32com.client` (for Windows) or `imaplib` (cross-platform, but requires IMAP access enabled in Outlook). * **Process:** 1. **Connect to Outlook:** * **`win32com.client` (Windows):** This is the most direct way to access Outlook on Windows. ```python import win32com.client outlook = win32com.client.Dispatch("Outlook.Application").GetNamespace("MAPI") inbox = outlook.GetDefaultFolder(6) # 6 represents the Inbox messages = inbox.Items ``` * **`imaplib` (Cross-Platform):** Requires IMAP to be enabled in your Outlook account settings. This is more complex to set up but works on macOS and Linux. ```python import imaplib import email # Replace with your Outlook IMAP server and credentials imap_server = "outlook.office365.com" imap_user = "your_email@outlook.com" imap_password = "your_password" mail = imaplib.IMAP4_SSL(imap_server) mail.login(imap_user, imap_password) mail.select("inbox") result, data = mail.search(None, "ALL") # Or use specific search criteria for num in data[0].split(): result, data = mail.fetch(num, "(RFC822)") raw_email = data[0][1] email_message = email.message_from_bytes(raw_email) # Process email_message mail.close() mail.logout() ``` 2. **Date Filtering:** Iterate through the emails and check their sent/received dates. * **`win32com.client`:** ```python import datetime start_date = datetime.datetime(2023, 1, 1) # Example start date end_date = datetime.datetime(2023, 12, 31) # Example end date for message in messages: try: sent_date = message.SentOn.replace(tzinfo=None) # Remove timezone info for comparison if start_date <= sent_date <= end_date: # Process the email print(f"Subject: {message.Subject}, Sent: {sent_date}") except Exception as e: print(f"Error processing email: {e}") ``` * **`imaplib`:** You can use IMAP search criteria for date filtering *before* fetching the emails, which is more efficient. ```python from datetime import date, timedelta today = date.today() yesterday = today - timedelta(days=1) date_str = yesterday.strftime("%d-%b-%Y") # Format required by IMAP result, data = mail.search(None, f'SINCE "{date_str}"') # Search for emails since yesterday ``` 3. **Email Data Extraction:** Extract relevant information from each email: * Subject * Sender * Recipient(s) * Sent/Received Date * Body (plain text and/or HTML) * Attachments (optional) **2. SQLite Database Storage:** * **Technology:** Python's `sqlite3` library. * **Process:** 1. **Connect to SQLite:** ```python import sqlite3 conn = sqlite3.connect('emails.db') cursor = conn.cursor() ``` 2. **Create a Table:** ```python cursor.execute(''' CREATE TABLE IF NOT EXISTS emails ( id INTEGER PRIMARY KEY AUTOINCREMENT, subject TEXT, sender TEXT, recipient TEXT, sent_date DATETIME, body TEXT ) ''') conn.commit() ``` 3. **Insert Email Data:** ```python def insert_email(subject, sender, recipient, sent_date, body): cursor.execute(''' INSERT INTO emails (subject, sender, recipient, sent_date, body) VALUES (?, ?, ?, ?, ?) ''', (subject, sender, recipient, sent_date, body)) conn.commit() # Example usage: insert_email(message.Subject, message.SenderEmailAddress, message.To, message.SentOn, message.Body) ``` 4. **Close the Connection:** ```python conn.close() ``` **3. Vector Embedding Generation:** * **Technology:** A suitable embedding model (e.g., Sentence Transformers, OpenAI's embeddings API, Hugging Face Transformers) and a library to use it. * **Process:** 1. **Choose an Embedding Model:** * **Sentence Transformers:** Good for general-purpose semantic similarity. Easy to use and can run locally. ```python from sentence_transformers import SentenceTransformer model = SentenceTransformer('all-mpnet-base-v2') # Choose a model ``` * **OpenAI Embeddings API:** High-quality embeddings, but requires an OpenAI API key and incurs costs. ```python import openai openai.api_key = "YOUR_OPENAI_API_KEY" def get_embedding(text, model="text-embedding-ada-002"): text = text.replace("\n", " ") return openai.Embedding.create(input = [text], model=model)['data'][0]['embedding'] ``` * **Hugging Face Transformers:** Offers a wide range of models, but can be more complex to set up. 2. **Generate Embeddings:** Create embeddings for the email body (or subject + body). ```python # Using Sentence Transformers email_body = message.Body # Or message.HTMLBody, but clean it first embedding = model.encode(email_body) # Using OpenAI email_body = message.Body embedding = get_embedding(email_body) ``` **4. MongoDB Storage with Vector Search:** * **Technology:** MongoDB with Atlas Vector Search. * **Process:** 1. **Connect to MongoDB:** ```python from pymongo import MongoClient # Replace with your MongoDB connection string client = MongoClient("mongodb+srv://<username>:<password>@<cluster>.mongodb.net/?retryWrites=true&w=majority") db = client["email_database"] collection = db["emails"] ``` 2. **Create a Vector Search Index (if it doesn't exist):** This is crucial for efficient vector search. You'll need to do this in the MongoDB Atlas UI or using the MongoDB shell. The index definition will depend on the embedding dimension of your chosen model. Example: ```javascript // MongoDB Shell db.emails.createIndex( { embedding: "vectorSearch", "indexConfig": { "dimensions": 768, // Replace with the dimension of your embedding model "similarity": "cosine", // Or "euclidean", "dotProduct" "vectorOptions": { "dataType": "float16", // Or "float32" "normalize": true } } }, { "name": "vectorSearchIndex" } ) ``` 3. **Store Email Data and Embeddings:** ```python def insert_email_mongo(subject, sender, recipient, sent_date, body, embedding): email_document = { "subject": subject, "sender": sender, "recipient": recipient, "sent_date": sent_date, "body": body, "embedding": embedding.tolist() # Convert NumPy array to list for MongoDB } collection.insert_one(email_document) # Example usage: insert_email_mongo(message.Subject, message.SenderEmailAddress, message.To, message.SentOn, message.Body, embedding) ``` **5. Semantic Search:** * **Process:** 1. **Get the Search Query:** The user enters a search query. 2. **Generate Embedding for the Query:** Use the *same* embedding model you used for the emails to generate an embedding for the search query. 3. **Perform Vector Search in MongoDB:** Use the `$vectorSearch` aggregation pipeline stage. ```python def search_emails(query, limit=10): query_embedding = model.encode(query).tolist() # Or get_embedding(query) if using OpenAI pipeline = [ { "$vectorSearch": { "index": "vectorSearchIndex", # The name of your vector search index "path": "embedding", "queryVector": query_embedding, "numCandidates": 100, # Adjust as needed "limit": limit } }, { "$project": { "_id": 0, "subject": 1, "body": 1, "score": { "$meta": "vectorSearchScore" } } } ] results = list(collection.aggregate(pipeline)) return results # Example usage: search_results = search_emails("meeting about project updates") for result in search_results: print(f"Subject: {result['subject']}, Score: {result['score']}") print(f"Body: {result['body'][:200]}...") # Print first 200 characters of the body ``` **Code Example (Illustrative - Requires Adaptation):** ```python import win32com.client import sqlite3 from sentence_transformers import SentenceTransformer from pymongo import MongoClient import datetime # --- Configuration --- SQLITE_DB_NAME = 'emails.db' MONGODB_CONNECTION_STRING = "mongodb+srv://<username>:<password>@<cluster>.mongodb.net/?retryWrites=true&w=majority" MONGODB_DATABASE_NAME = "email_database" MONGODB_COLLECTION_NAME = "emails" EMBEDDING_MODEL_NAME = 'all-mpnet-base-v2' # Or 'text-embedding-ada-002' if using OpenAI # --- Initialize Components --- outlook = win32com.client.Dispatch("Outlook.Application").GetNamespace("MAPI") inbox = outlook.GetDefaultFolder(6) messages = inbox.Items sqlite_conn = sqlite3.connect(SQLITE_DB_NAME) sqlite_cursor = sqlite_conn.cursor() model = SentenceTransformer(EMBEDDING_MODEL_NAME) # Or initialize OpenAI mongo_client = MongoClient(MONGODB_CONNECTION_STRING) mongo_db = mongo_client[MONGODB_DATABASE_NAME] mongo_collection = mongo_db[MONGODB_COLLECTION_NAME] # --- Database Setup --- sqlite_cursor.execute(''' CREATE TABLE IF NOT EXISTS emails ( id INTEGER PRIMARY KEY AUTOINCREMENT, subject TEXT, sender TEXT, recipient TEXT, sent_date DATETIME, body TEXT ) ''') sqlite_conn.commit() # --- Email Processing --- start_date = datetime.datetime(2023, 1, 1) end_date = datetime.datetime(2023, 12, 31) for message in messages: try: sent_date = message.SentOn.replace(tzinfo=None) if start_date <= sent_date <= end_date: subject = message.Subject sender = message.SenderEmailAddress recipient = message.To body = message.Body # 1. Store in SQLite sqlite_cursor.execute(''' INSERT INTO emails (subject, sender, recipient, sent_date, body) VALUES (?, ?, ?, ?, ?) ''', (subject, sender, recipient, sent_date, body)) sqlite_conn.commit() # 2. Generate Embedding embedding = model.encode(body) # Or use OpenAI # 3. Store in MongoDB email_document = { "subject": subject, "sender": sender, "recipient": recipient, "sent_date": sent_date, "body": body, "embedding": embedding.tolist() } mongo_collection.insert_one(email_document) print(f"Processed email: {subject}") except Exception as e: print(f"Error processing email: {e}") # --- Cleanup --- sqlite_conn.close() mongo_client.close() print("Email processing complete.") ``` **Key Considerations and Improvements:** * **Error Handling:** Robust error handling is crucial, especially when dealing with external APIs and data sources. Use `try...except` blocks extensively. * **Rate Limiting:** Be mindful of rate limits for the OpenAI API and other services. Implement delays or batch processing to avoid exceeding limits. * **Authentication:** Securely store and manage API keys and database credentials. Avoid hardcoding them directly in your script. Use environment variables or a configuration file. * **Data Cleaning:** Clean the email body before generating embeddings. Remove HTML tags, special characters, and irrelevant content. Consider using libraries like `BeautifulSoup` for HTML parsing. * **Scalability:** For large email datasets, consider using batch processing and asynchronous tasks to improve performance. Libraries like `Celery` or `Dask` can help. * **Incremental Updates:** Implement a mechanism to periodically check for new emails and update the databases and embeddings. You could use a scheduled task or a background process. * **Vector Search Index Optimization:** Experiment with different vector search index configurations (e.g., `numCandidates`, `similarity metric`) to optimize search performance. * **User Interface:** Create a user interface (e.g., using Flask, Django, or Streamlit) to allow users to enter search queries and view the results. * **Security:** If you're handling sensitive email data, implement appropriate security measures to protect the data at rest and in transit. * **Time Zones:** Pay close attention to time zones when filtering emails by date. Ensure that all dates are in the same time zone before comparing them. * **Attachment Handling:** If you need to process attachments, you'll need to extract them from the emails and store them separately. You could also generate embeddings for the attachment content. * **IMAP vs. Exchange Web Services (EWS):** For more advanced Outlook integration, consider using Exchange Web Services (EWS) instead of IMAP. EWS provides more features and better performance, but it's also more complex to set up. There are Python libraries like `exchangelib` that can help. This comprehensive outline should give you a solid foundation for building your email processing and semantic search application. Remember to adapt the code examples to your specific needs and environment. Good luck! **Simplified Chinese Translation of the Key Concepts:** Here's a translation of the key concepts into Simplified Chinese: * **Outlook Email Extraction:** Outlook 邮件提取 (Outlook yóujiàn tíqǔ) * **Date Filtering:** 日期过滤 (rìqí guòlǜ) * **SQLite Database:** SQLite 数据库 (SQLite shùjùkù) * **Vector Embeddings:** 向量嵌入 (xiàngliàng qiànrù) * **Semantic Search:** 语义搜索 (yǔyì sōusuǒ) * **MongoDB:** MongoDB * **Atlas Vector Search:** Atlas 向量搜索 (Atlas xiàngliàng sōusuǒ) * **Sentence Transformers:** 句子转换器 (jùzi zhuǎnhuànqì) * **OpenAI Embeddings API:** OpenAI 嵌入 API (OpenAI qiànrù API) * **Hugging Face Transformers:** Hugging Face 转换器 (Hugging Face zhuǎnhuànqì) * **Email Body:** 邮件正文 (yóujiàn zhèngwén) * **Search Query:** 搜索查询 (sōusuǒ cháxún) * **Aggregation Pipeline:** 聚合管道 (jùhé guǎndào) * **Index:** 索引 (suǒyǐn) * **Connection String:** 连接字符串 (liánjiē zìfúchuàn) * **Rate Limiting:** 速率限制 (sùlǜ xiànzhì) * **Data Cleaning:** 数据清洗 (shùjù qīngxǐ) * **Scalability:** 可扩展性 (kě kuòzhǎn xìng) * **Incremental Updates:** 增量更新 (zēngliàng gēngxīn) * **User Interface:** 用户界面 (yònghù jièmiàn) * **Security:** 安全性 (ānquán xìng) * **Time Zones:** 时区 (shíqū) * **Attachment Handling:** 附件处理 (fùjiàn chǔlǐ) * **Exchange Web Services (EWS):** Exchange Web 服务 (EWS)

Wegene Assistant MCP Server

利用大型语言模型分析用户的微基因（WeGene）基因检测报告，通过自定义 URI 方案提供对报告数据的访问，并通过 OAuth 认证和 API 使用实现个人资料和报告管理。

ma-browser

MCP server that lets AI agents use your real browser as an API, accessing any website with your login state, no keys or scrapers needed.