Discover Awesome MCP Servers

Tavily Search

Uma implementação de servidor MCP que integra a API de Busca Tavily, fornecendo capacidades de busca otimizadas para LLMs.

MCP 만들면서 원리 파헤쳐보기

Okay, here's a breakdown of the server and client implementation for a Master Control Program (MCP), along with considerations and potential approaches. Keep in mind that "Master Control Program" is a very broad term, and the specific requirements will heavily influence the design. I'll provide a general framework and then discuss some common scenarios. **General Concepts** The MCP, in this context, typically refers to a central system that manages and controls other systems (clients). It's a common architecture in distributed systems, industrial automation, and even some software applications. * **Server (MCP Server):** The central authority. It receives requests from clients, processes them, and potentially sends commands or data back to the clients. It often maintains a global view of the system's state. * **Client:** A system or application that is managed by the MCP. It communicates with the MCP server to report its status, request resources, or execute commands. **Key Considerations Before Implementation** Before diving into code, consider these factors: * **Communication Protocol:** How will the server and clients communicate? Common choices include: * **TCP/IP:** Reliable, connection-oriented. Good for guaranteed delivery and persistent connections. Suitable for command-and-control scenarios. * **UDP:** Faster, connectionless. Good for real-time data streaming or situations where occasional packet loss is acceptable. * **HTTP/HTTPS:** Simple to implement, uses standard web infrastructure. Good for RESTful APIs and web-based control panels. * **Message Queues (e.g., RabbitMQ, Kafka):** Asynchronous communication. Good for decoupling the server and clients and handling high volumes of messages. * **gRPC:** High-performance, uses Protocol Buffers for serialization. Good for microservices and demanding applications. * **Data Serialization:** How will data be encoded for transmission? * **JSON:** Human-readable, widely supported. * **XML:** More verbose than JSON, but still widely used. * **Protocol Buffers:** Binary format, efficient and supports schema evolution. Excellent for gRPC. * **MessagePack:** Binary format, similar to JSON but more compact. * **Security:** How will you authenticate clients and protect data in transit? * **TLS/SSL:** Encrypts communication. * **Authentication (e.g., API keys, OAuth):** Verifies the identity of clients. * **Authorization:** Controls what actions clients are allowed to perform. * **Scalability:** How many clients will the MCP need to support? Will it need to handle a high volume of requests? * **Fault Tolerance:** What happens if the MCP server fails? Will there be a backup? How will clients handle disconnections? * **Real-time Requirements:** Does the MCP need to respond to events in real-time? * **Complexity:** How complex are the commands and data structures that need to be exchanged? * **Existing Infrastructure:** Are there existing systems or libraries that you can leverage? * **Programming Languages:** Choose languages suitable for both server and client. Python, Java, Go, C++, and C# are common choices. **Example Implementation (Python with TCP/IP and JSON)** This is a simplified example to illustrate the basic concepts. It's not production-ready, but it provides a starting point. **Server (mcp_server.py):** ```python import socket import json import threading HOST = '127.0.0.1' # Standard loopback interface address (localhost) PORT = 65432 # Port to listen on (non-privileged ports are > 1023) # Global dictionary to store client states (example) client_states = {} def handle_client(conn, addr): print(f"Connected by {addr}") while True: try: data = conn.recv(1024) # Receive data in 1024-byte chunks if not data: break # Client disconnected try: request = json.loads(data.decode('utf-8')) print(f"Received from {addr}: {request}") # Process the request (example) if 'command' in request: command = request['command'] if command == 'report_status': client_id = request.get('client_id') status = request.get('status') if client_id and status: client_states[client_id] = status print(f"Client {client_id} status updated: {status}") response = {'status': 'ok', 'message': 'Status received'} else: response = {'status': 'error', 'message': 'Missing client_id or status'} elif command == 'get_all_statuses': response = {'status': 'ok', 'statuses': client_states} else: response = {'status': 'error', 'message': 'Unknown command'} else: response = {'status': 'error', 'message': 'No command specified'} conn.sendall(json.dumps(response).encode('utf-8')) except json.JSONDecodeError: print(f"Invalid JSON received from {addr}") conn.sendall(json.dumps({'status': 'error', 'message': 'Invalid JSON'}).encode('utf-8')) except ConnectionResetError: print(f"Client {addr} disconnected abruptly.") break except Exception as e: print(f"Error handling client {addr}: {e}") break print(f"Disconnected from {addr}") conn.close() with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.bind((HOST, PORT)) s.listen() print(f"Listening on {HOST}:{PORT}") while True: conn, addr = s.accept() thread = threading.Thread(target=handle_client, args=(conn, addr)) thread.start() ``` **Client (mcp_client.py):** ```python import socket import json import time HOST = '127.0.0.1' # The server's hostname or IP address PORT = 65432 # The port used by the server def send_request(command, data=None): with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: try: s.connect((HOST, PORT)) request = {'command': command} if data: request.update(data) s.sendall(json.dumps(request).encode('utf-8')) response_data = s.recv(1024) response = json.loads(response_data.decode('utf-8')) return response except ConnectionRefusedError: print("Connection refused. Is the server running?") return None except Exception as e: print(f"Error: {e}") return None if __name__ == "__main__": client_id = "client_123" # Unique identifier for this client # Example: Report status to the server status_report = {'client_id': client_id, 'status': 'idle'} response = send_request('report_status', status_report) if response and response['status'] == 'ok': print("Status reported successfully.") else: print("Failed to report status:", response) time.sleep(2) # Example: Get all statuses from the server response = send_request('get_all_statuses') if response and response['status'] == 'ok': print("All statuses:", response['statuses']) else: print("Failed to get statuses:", response) ``` **How to Run:** 1. Save the code as `mcp_server.py` and `mcp_client.py`. 2. Open two terminal windows. 3. In the first terminal, run the server: `python mcp_server.py` 4. In the second terminal, run the client: `python mcp_client.py` **Explanation:** * **Server:** * Creates a TCP socket and listens for incoming connections. * Accepts connections in a loop. * Spawns a new thread for each client connection to handle it concurrently. * Receives data from the client, decodes it as JSON, and processes the request. * Sends a JSON-encoded response back to the client. * Handles potential errors (e.g., invalid JSON, client disconnection). * **Client:** * Creates a TCP socket and connects to the server. * Constructs a JSON request with a `command` and optional `data`. * Sends the request to the server. * Receives the response from the server, decodes it as JSON, and prints the result. * Includes error handling for connection issues. **Important Considerations for Production:** * **Error Handling:** The example has basic error handling, but you'll need more robust error handling in a production environment. Log errors, implement retry mechanisms, and handle unexpected exceptions gracefully. * **Logging:** Implement comprehensive logging to track events, errors, and performance metrics. * **Configuration:** Use configuration files (e.g., YAML, JSON) to store settings like the server address, port, and logging level. Avoid hardcoding these values. * **Thread Safety:** If the server needs to access shared resources (like the `client_states` dictionary in the example), use appropriate locking mechanisms (e.g., `threading.Lock`) to prevent race conditions. * **Connection Pooling:** For high-volume scenarios, consider using connection pooling on the client side to reuse connections and reduce overhead. * **Heartbeats:** Implement heartbeats (periodic messages from clients to the server) to detect disconnected clients. * **Command Queueing:** If the server needs to handle a large number of commands, consider using a command queue to process them asynchronously. * **Monitoring:** Monitor the server's performance (CPU usage, memory usage, network traffic) to identify potential bottlenecks. * **Deployment:** Consider how you will deploy the server and clients (e.g., Docker containers, virtual machines). * **Security Best Practices:** Follow security best practices to protect the MCP from unauthorized access and attacks. This includes using strong authentication, encrypting communication, and regularly patching vulnerabilities. **Alternative Architectures and Technologies** * **Message Queues (RabbitMQ, Kafka):** Instead of direct TCP/IP connections, clients can send messages to a message queue, and the MCP server can consume messages from the queue. This provides decoupling and allows for asynchronous communication. * **RESTful API (HTTP/HTTPS):** The MCP server can expose a RESTful API that clients can use to send requests. This is a good option if you need to integrate with web-based applications. Frameworks like Flask (Python), Spring Boot (Java), and ASP.NET Core (C#) can be used to build RESTful APIs. * **gRPC:** For high-performance communication, gRPC is a good choice. It uses Protocol Buffers for serialization and supports bidirectional streaming. * **WebSockets:** For real-time, bidirectional communication between the server and clients, WebSockets are a good option. **Example Scenarios and Specific Considerations** * **Industrial Automation:** The MCP might control robots, sensors, and other devices on a factory floor. Real-time performance and reliability are critical. Consider using a real-time operating system (RTOS) for the server and clients. Protocols like Modbus or OPC UA might be used for communication. * **Game Server Management:** The MCP might manage multiple game servers, allocating resources, monitoring their status, and handling player authentication. Scalability and fault tolerance are important. Consider using a distributed database to store game server state. * **Cloud Resource Management:** The MCP might manage virtual machines, containers, and other cloud resources. Integration with cloud APIs (e.g., AWS, Azure, GCP) is essential. * **Software Application Management:** The MCP might manage the deployment, configuration, and monitoring of software applications. **Translation to Portuguese** Here's the translation of the above explanation into Portuguese: **Implementação do Servidor e Cliente para MCP (Master Control Program)** Aqui está uma análise da implementação do servidor e cliente para um Master Control Program (MCP), juntamente com considerações e abordagens potenciais. Lembre-se de que "Master Control Program" é um termo muito amplo, e os requisitos específicos influenciarão fortemente o design. Fornecerei uma estrutura geral e, em seguida, discutirei alguns cenários comuns. **Conceitos Gerais** O MCP, neste contexto, normalmente se refere a um sistema central que gerencia e controla outros sistemas (clientes). É uma arquitetura comum em sistemas distribuídos, automação industrial e até mesmo em alguns aplicativos de software. * **Servidor (Servidor MCP):** A autoridade central. Ele recebe solicitações de clientes, as processa e, potencialmente, envia comandos ou dados de volta para os clientes. Ele geralmente mantém uma visão global do estado do sistema. * **Cliente:** Um sistema ou aplicativo que é gerenciado pelo MCP. Ele se comunica com o servidor MCP para relatar seu status, solicitar recursos ou executar comandos. **Considerações Chave Antes da Implementação** Antes de mergulhar no código, considere estes fatores: * **Protocolo de Comunicação:** Como o servidor e os clientes se comunicarão? As opções comuns incluem: * **TCP/IP:** Confiável, orientado à conexão. Bom para entrega garantida e conexões persistentes. Adequado para cenários de comando e controle. * **UDP:** Mais rápido, sem conexão. Bom para streaming de dados em tempo real ou situações em que a perda ocasional de pacotes é aceitável. * **HTTP/HTTPS:** Simples de implementar, usa infraestrutura web padrão. Bom para APIs RESTful e painéis de controle baseados na web. * **Filas de Mensagens (por exemplo, RabbitMQ, Kafka):** Comunicação assíncrona. Bom para desacoplar o servidor e os clientes e lidar com grandes volumes de mensagens. * **gRPC:** Alto desempenho, usa Protocol Buffers para serialização. Bom para microsserviços e aplicações exigentes. * **Serialização de Dados:** Como os dados serão codificados para transmissão? * **JSON:** Legível por humanos, amplamente suportado. * **XML:** Mais verboso que JSON, mas ainda amplamente utilizado. * **Protocol Buffers:** Formato binário, eficiente e suporta evolução de esquema. Excelente para gRPC. * **MessagePack:** Formato binário, semelhante ao JSON, mas mais compacto. * **Segurança:** Como você autenticará os clientes e protegerá os dados em trânsito? * **TLS/SSL:** Criptografa a comunicação. * **Autenticação (por exemplo, chaves de API, OAuth):** Verifica a identidade dos clientes. * **Autorização:** Controla quais ações os clientes podem executar. * **Escalabilidade:** Quantos clientes o MCP precisará suportar? Ele precisará lidar com um grande volume de solicitações? * **Tolerância a Falhas:** O que acontece se o servidor MCP falhar? Haverá um backup? Como os clientes lidarão com as desconexões? * **Requisitos de Tempo Real:** O MCP precisa responder a eventos em tempo real? * **Complexidade:** Quão complexos são os comandos e as estruturas de dados que precisam ser trocados? * **Infraestrutura Existente:** Existem sistemas ou bibliotecas existentes que você pode aproveitar? * **Linguagens de Programação:** Escolha linguagens adequadas para servidor e cliente. Python, Java, Go, C++ e C# são escolhas comuns. **Exemplo de Implementação (Python com TCP/IP e JSON)** Este é um exemplo simplificado para ilustrar os conceitos básicos. Não está pronto para produção, mas fornece um ponto de partida. **Servidor (mcp_server.py):** ```python import socket import json import threading HOST = '127.0.0.1' # Endereço de interface de loopback padrão (localhost) PORT = 65432 # Porta para escutar (portas não privilegiadas são > 1023) # Dicionário global para armazenar estados do cliente (exemplo) client_states = {} def handle_client(conn, addr): print(f"Conectado por {addr}") while True: try: data = conn.recv(1024) # Recebe dados em blocos de 1024 bytes if not data: break # Cliente desconectado try: request = json.loads(data.decode('utf-8')) print(f"Recebido de {addr}: {request}") # Processa a solicitação (exemplo) if 'command' in request: command = request['command'] if command == 'report_status': client_id = request.get('client_id') status = request.get('status') if client_id and status: client_states[client_id] = status print(f"Status do cliente {client_id} atualizado: {status}") response = {'status': 'ok', 'message': 'Status recebido'} else: response = {'status': 'error', 'message': 'client_id ou status ausente'} elif command == 'get_all_statuses': response = {'status': 'ok', 'statuses': client_states} else: response = {'status': 'error', 'message': 'Comando desconhecido'} else: response = {'status': 'error', 'message': 'Nenhum comando especificado'} conn.sendall(json.dumps(response).encode('utf-8')) except json.JSONDecodeError: print(f"JSON inválido recebido de {addr}") conn.sendall(json.dumps({'status': 'error', 'message': 'JSON inválido'}).encode('utf-8')) except ConnectionResetError: print(f"Cliente {addr} desconectado abruptamente.") break except Exception as e: print(f"Erro ao lidar com o cliente {addr}: {e}") break print(f"Desconectado de {addr}") conn.close() with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.bind((HOST, PORT)) s.listen() print(f"Escutando em {HOST}:{PORT}") while True: conn, addr = s.accept() thread = threading.Thread(target=handle_client, args=(conn, addr)) thread.start() ``` **Cliente (mcp_client.py):** ```python import socket import json import time HOST = '127.0.0.1' # O nome do host ou endereço IP do servidor PORT = 65432 # A porta usada pelo servidor def send_request(command, data=None): with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: try: s.connect((HOST, PORT)) request = {'command': command} if data: request.update(data) s.sendall(json.dumps(request).encode('utf-8')) response_data = s.recv(1024) response = json.loads(response_data.decode('utf-8')) return response except ConnectionRefusedError: print("Conexão recusada. O servidor está em execução?") return None except Exception as e: print(f"Erro: {e}") return None if __name__ == "__main__": client_id = "client_123" # Identificador único para este cliente # Exemplo: Relatar o status para o servidor status_report = {'client_id': client_id, 'status': 'idle'} response = send_request('report_status', status_report) if response and response['status'] == 'ok': print("Status relatado com sucesso.") else: print("Falha ao relatar o status:", response) time.sleep(2) # Exemplo: Obter todos os status do servidor response = send_request('get_all_statuses') if response and response['status'] == 'ok': print("Todos os status:", response['statuses']) else: print("Falha ao obter os status:", response) ``` **Como Executar:** 1. Salve o código como `mcp_server.py` e `mcp_client.py`. 2. Abra duas janelas de terminal. 3. No primeiro terminal, execute o servidor: `python mcp_server.py` 4. No segundo terminal, execute o cliente: `python mcp_client.py` **Explicação:** * **Servidor:** * Cria um socket TCP e escuta por conexões de entrada. * Aceita conexões em um loop. * Gera uma nova thread para cada conexão de cliente para lidar com ela simultaneamente. * Recebe dados do cliente, decodifica-os como JSON e processa a solicitação. * Envia uma resposta codificada em JSON de volta para o cliente. * Lida com possíveis erros (por exemplo, JSON inválido, desconexão do cliente). * **Cliente:** * Cria um socket TCP e se conecta ao servidor. * Constrói uma solicitação JSON com um `command` e `data` opcional. * Envia a solicitação para o servidor. * Recebe a resposta do servidor, decodifica-a como JSON e imprime o resultado. * Inclui tratamento de erros para problemas de conexão. **Considerações Importantes para Produção:** * **Tratamento de Erros:** O exemplo tem tratamento de erros básico, mas você precisará de um tratamento de erros mais robusto em um ambiente de produção. Registre erros, implemente mecanismos de repetição e lide com exceções inesperadas de forma elegante. * **Registro (Logging):** Implemente um registro abrangente para rastrear eventos, erros e métricas de desempenho. * **Configuração:** Use arquivos de configuração (por exemplo, YAML, JSON) para armazenar configurações como o endereço do servidor, a porta e o nível de registro. Evite codificar esses valores. * **Segurança de Thread:** Se o servidor precisar acessar recursos compartilhados (como o dicionário `client_states` no exemplo), use mecanismos de bloqueio apropriados (por exemplo, `threading.Lock`) para evitar condições de corrida. * **Pool de Conexões:** Para cenários de alto volume, considere usar um pool de conexões no lado do cliente para reutilizar conexões e reduzir a sobrecarga. * **Heartbeats:** Implemente heartbeats (mensagens periódicas de clientes para o servidor) para detectar clientes desconectados. * **Fila de Comandos:** Se o servidor precisar lidar com um grande número de comandos, considere usar uma fila de comandos para processá-los de forma assíncrona. * **Monitoramento:** Monitore o desempenho do servidor (uso de CPU, uso de memória, tráfego de rede) para identificar possíveis gargalos. * **Implantação:** Considere como você implantará o servidor e os clientes (por exemplo, contêineres Docker, máquinas virtuais). * **Práticas Recomendadas de Segurança:** Siga as práticas recomendadas de segurança para proteger o MCP contra acesso não autorizado e ataques. Isso inclui o uso de autenticação forte, criptografia de comunicação e aplicação regular de patches de vulnerabilidades. **Arquiteturas e Tecnologias Alternativas** * **Filas de Mensagens (RabbitMQ, Kafka):** Em vez de conexões TCP/IP diretas, os clientes podem enviar mensagens para uma fila de mensagens e o servidor MCP pode consumir mensagens da fila. Isso fornece desacoplamento e permite a comunicação assíncrona. * **API RESTful (HTTP/HTTPS):** O servidor MCP pode expor uma API RESTful que os clientes podem usar para enviar solicitações. Esta é uma boa opção se você precisar integrar com aplicativos baseados na web. Frameworks como Flask (Python), Spring Boot (Java) e ASP.NET Core (C#) podem ser usados para construir APIs RESTful. * **gRPC:** Para comunicação de alto desempenho, o gRPC é uma boa escolha. Ele usa Protocol Buffers para serialização e suporta streaming bidirecional. * **WebSockets:** Para comunicação bidirecional em tempo real entre o servidor e os clientes, os WebSockets são uma boa opção. **Cenários de Exemplo e Considerações Específicas** * **Automação Industrial:** O MCP pode controlar robôs, sensores e outros dispositivos em uma fábrica. O desempenho em tempo real e a confiabilidade são críticos. Considere usar um sistema operacional em tempo real (RTOS) para o servidor e os clientes. Protocolos como Modbus ou OPC UA podem ser usados para comunicação. * **Gerenciamento de Servidores de Jogos:** O MCP pode gerenciar vários servidores de jogos, alocando recursos, monitorando seu status e lidando com a autenticação do jogador. Escalabilidade e tolerância a falhas são importantes. Considere usar um banco de dados distribuído para armazenar o estado do servidor de jogos. * **Gerenciamento de Recursos na Nuvem:** O MCP pode gerenciar máquinas virtuais, contêineres e outros recursos na nuvem. A integração com APIs de nuvem (por exemplo, AWS, Azure, GCP) é essencial. * **Gerenciamento de Aplicações de Software:** O MCP pode gerenciar a implantação, configuração e monitoramento de aplicações de software. This translation aims to be accurate and understandable. Let me know if you have any other questions.

garmin-mcp-bridge

Brings Garmin training data into Claude via Intervals.icu, enabling querying of activities, wellness, and planned workouts, as well as creating structured workouts that sync back to the Garmin watch.

FastAPI Apcore MCP Server

Exposes FastAPI routes as MCP tools with auto-discovery, Pydantic schema extraction, and built-in observability.

Twilio MCP

Enables sending SMS text messages through Twilio's messaging service with a simple send_text tool that supports configurable recipients and messaging service integration.

signalis-mcp

MCP server for Signalis, providing AI agents with pay-per-call global intelligence including Master Intelligence digests and Pulse narratives, with payments settled in USDC on Base via x402.

Bambu/OrcaSlicer MCP Agent

A Model Context Protocol (MCP) server that acts as a manufacturing consultant for 3D printing, analyzing .3mf print files and recommending optimal settings for speed vs. strength trade-offs.

agoda-review-mcp

Servidor MCP para encontrar avaliações de hotéis na Agoda.

picoli-mcp

Enables URL shortening, click tracking, and analytics for AI agents via the picoli.site API.

Simple MCP Server with upstream auth via local rest endpoint

Um ambiente de testes para prototipagem de servidores MCP.

Kastell

Server security auditing (413 checks, 29 categories), production hardening, and fleet management. Supports Hetzner, DigitalOcean, Vultr, and Linode.

Jokes MCP Server

Provides access to various joke APIs including Chuck Norris jokes, Dad jokes, and Yo Mama jokes. Integrates with Microsoft Copilot Studio to create humor-focused agents that can deliver jokes on demand.

ntfy MCP Server

Send push notifications to mobile devices via ntfy.sh from AI assistants.

Grants.gov MCP Server

Model Context Protocol (MCP) server that provides access to the Grants.gov API for searching and retrieving federal grant opportunities.

io.github.daedalus/mcp-cryptography

Exposes various cryptographic operations including key generation, symmetric/asymmetric encryption, hashing, and HMAC. Supports Fernet, AES, RSA, X.25519, and X.509 certificates.

easy-mysql-mcp

Enables AI assistants to inspect and query a MySQL database through safe, structured tools, including schema discovery and read-only queries.

pydantic-zotero-mcp

An MCP server that gives AI agents read access to a Zotero library, enabling search, item metadata, collections, tags, notes, and full-text search of attached PDFs.

YARR Media Stack MCP Server

A comprehensive Model Context Protocol server that bridges LLMs with self-hosted media services, enabling natural language control of TV shows, movies, downloads, and notifications while maintaining traditional API access.

SpyNet

Enables AI assistants to configure and manage session-based REST and WebSocket mock servers for application development and testing. It allows for dynamic endpoint setup, request history inspection, and real-time WebSocket communication through natural language commands.

mcp-memory-sqlite

A personal knowledge graph and memory system for AI assistants using SQLite with FTS5 full-text search, enabling persistent memory across conversations with Claude or any MCP-compatible AI.

Agentic Browser MCP Server

A local MCP server that connects to a Chrome extension to enable AI agents to control browser tabs, execute automation, and interact with web pages via tools.

humane-proxy

It's a safety middleware that can detect and intercept self-harm and criminal intent at 3 stages. It allows developers of chat-based platforms to configure webhook notifications and store encrypted information for prior mitigation of any such cases.

psx-mcp

MCP server that exposes Pakistan Stock Exchange data (quotes, dividends, announcements, indices) as LLM-callable tools, enabling conversational market queries in plain English.

GitHub MCP Wrapper

Enables claude.ai to connect to GitHub MCP using OAuth, providing full toolset for repository, issue, PR, Actions, and gist operations.

nginx-proxy-manager-mcp

Enables AI agents to manage Nginx Proxy Manager (reverse proxies, streams, redirects, and Let's Encrypt certificates) through natural language commands.

pico-mcp

Enables LLMs to control a PicoScope 5000A USB oscilloscope for signal generation, block capture, measurements, and frequency response sweeps.

SDG Function Generator MCP Server

Enables remote control of Siglent SDG series function/arbitrary waveform generators via SCPI over TCP/IP. Provides tools for configuring waveforms, modulation, sweep, burst, and other instrument functions.

PactAI MCP

Serves coding agents with project-specific knowledge (decisions, conventions, constraints) over MCP and provides verification verdicts on whether code still complies.

log-reflect-mcp

Captures and retrieves Markdown records for a personal recording system, enabling journaling, input tracking, search, and date-range review.

obsidian-mcp-pro

Provides AI agents with comprehensive access to Obsidian vaults, enabling reading, writing, searching, tagging, linking, canvas manipulation, and semantic search through 41 tools.