Discover Awesome MCP Servers

saras-mcp

Please be more specific. "MCP server code for Saras" is too vague. To provide you with useful information, I need to know what you're trying to accomplish. For example, are you looking for: * **Code for a Minecraft server using the Mod Coder Pack (MCP) and specifically tailored for a mod called "Saras"?** If so, I need to know what "Saras" is supposed to *do*. What features does this mod add? What are its core mechanics? * **Code that *interacts* with a server running a "Saras" mod?** If so, what kind of interaction are you looking for? Are you trying to send commands, read data, or something else? * **Something else entirely?** The more details you give me, the better I can assist you. In the meantime, here's a general overview of what's involved in creating a Minecraft server with mods using MCP: 1. **Set up your development environment:** * Install Java Development Kit (JDK). * Download and set up your IDE (e.g., IntelliJ IDEA, Eclipse). * Download and set up the Mod Coder Pack (MCP). MCP is used to decompile, deobfuscate, and recompile Minecraft code. It's essential for modding. You'll need to choose the correct MCP version for the Minecraft version you're targeting. 2. **Decompile Minecraft:** Use MCP to decompile the Minecraft server and client code. This will give you readable (though still somewhat obfuscated) source code. 3. **Create your mod project:** Within your IDE, create a new project and set up the necessary dependencies (Minecraft libraries provided by MCP). 4. **Write your mod code:** This is where you implement the features of your "Saras" mod. You'll use the Minecraft API (exposed through MCP) to add new blocks, items, entities, commands, etc. 5. **Build your mod:** Compile your code into a `.jar` file. 6. **Set up a Minecraft server:** * Download the Minecraft server `.jar` file from Mojang. * Create a folder for your server. * Place the server `.jar` file in the folder. * Run the server once to generate the necessary configuration files (e.g., `server.properties`). 7. **Install your mod:** Place your mod's `.jar` file in the `mods` folder within your Minecraft server directory. You may also need to install Forge or Fabric, depending on how your mod is designed. 8. **Configure your server:** Edit the `server.properties` file to customize your server settings (e.g., game mode, difficulty, port). 9. **Run your server:** Start the server and test your mod. **Example (very basic, just to illustrate the structure):** Let's say "Saras" is a simple mod that adds a new block called "SarasBlock". Here's a simplified example of what the code might look like (using Forge): ```java // Example SarasMod.java (main mod class) package com.example.sarasmod; import net.minecraft.block.Block; import net.minecraft.block.material.Material; import net.minecraft.item.BlockItem; import net.minecraft.item.Item; import net.minecraft.item.ItemGroup; import net.minecraftforge.common.MinecraftForge; import net.minecraftforge.event.RegistryEvent; import net.minecraftforge.eventbus.api.SubscribeEvent; import net.minecraftforge.fml.common.Mod; import net.minecraftforge.fml.event.lifecycle.FMLClientSetupEvent; import net.minecraftforge.fml.event.lifecycle.FMLCommonSetupEvent; import net.minecraftforge.fml.javafmlmod.FMLJavaModLoadingContext; import net.minecraftforge.registries.IForgeRegistry; import net.minecraftforge.registries.ObjectHolder; @Mod("sarasmod") // Replace with your mod ID public class SarasMod { public static final String MOD_ID = "sarasmod"; public SarasMod() { FMLJavaModLoadingContext.get().getModEventBus().addListener(this::setup); FMLJavaModLoadingContext.get().getModEventBus().addListener(this::doClientStuff); MinecraftForge.EVENT_BUS.register(this); } private void setup(final FMLCommonSetupEvent event) { // Some common setup code } private void doClientStuff(final FMLClientSetupEvent event) { // Do something that relies on the client only } @Mod.EventBusSubscriber(bus = Mod.EventBusSubscriber.Bus.MOD) public static class RegistryEvents { @SubscribeEvent public static void onBlocksRegistry(final RegistryEvent.Register<Block> blockRegistryEvent) { blockRegistryEvent.getRegistry().register(new SarasBlock()); } @SubscribeEvent public static void onItemsRegistry(final RegistryEvent.Register<Item> itemRegistryEvent) { itemRegistryEvent.getRegistry().register(new BlockItem(SarasBlock.SARAS_BLOCK, new Item.Properties().group(ItemGroup.MISC)).setRegistryName(SarasBlock.SARAS_BLOCK.getRegistryName())); } } @ObjectHolder(MOD_ID + ":saras_block") public static SarasBlock sarasBlock; } // Example SarasBlock.java package com.example.sarasmod; import net.minecraft.block.Block; import net.minecraft.block.material.Material; import net.minecraft.util.ResourceLocation; public class SarasBlock extends Block { public static final SarasBlock SARAS_BLOCK = new SarasBlock(); public SarasBlock() { super(Block.Properties.create(Material.ROCK)); setRegistryName(new ResourceLocation(SarasMod.MOD_ID, "saras_block")); } } ``` **Important Considerations:** * **Minecraft Version:** The code and APIs change between Minecraft versions. Make sure you're using the correct MCP and Forge/Fabric versions for the Minecraft version you're targeting. * **Forge/Fabric:** Forge and Fabric are modding APIs that provide a more stable and easier-to-use interface for modding Minecraft. Most modern mods use one of these. You'll need to choose one and set it up in your development environment. * **Obfuscation:** Minecraft code is obfuscated, meaning the names of classes and methods are deliberately made difficult to understand. MCP helps with deobfuscation, but it's still not perfect. * **Licensing:** Be aware of the licensing terms of Minecraft and any libraries you use in your mod. **To get more specific code, please tell me:** * **What is "Saras"?** Describe the mod's functionality. * **What Minecraft version are you targeting?** * **Are you using Forge or Fabric?** * **What specific part of the server code are you interested in?** (e.g., adding a new command, handling a specific event, modifying existing game mechanics) Once I have this information, I can provide more relevant and helpful code examples.

Mcp Forge

MCP-Forge é uma estrutura poderosa para gerar, gerenciar e monitorar dinamicamente servidores do Protocolo de Contexto de Modelo (MCP). Usando o SDK MCP oficial, esta ferramenta permite que você crie servidores MCP especializados sob demanda através de uma interface centralizada.

estudIA-MCP

RAG-enabled MCP server that uses Google Gemini for embeddings and Supabase for vector storage, enabling semantic search and document similarity matching through natural language queries.

Docker MCP Server

Enables secure execution of shell commands and file operations within isolated Docker containers. Provides process management, interactive input handling, and comprehensive file system operations for containerized development environments.

Qdrant MCP Server

Provides semantic memory capabilities using Qdrant vector database with configurable embedding providers, allowing storage and retrieval of information using vector similarity.

Securities prices MCP server sample

Aqui está um exemplo de um servidor MCP (Market Connectivity Platform) para preços de títulos, informações históricas, etc.: (Note: This is a conceptual outline. Building a full MCP server requires significant development effort and depends heavily on the specific technologies and protocols you intend to support.) ```python # Conceptual MCP Server (Python Example) import asyncio import websockets import json import datetime # --- Data Sources (Replace with actual data feeds) --- # Mock historical data (replace with database or API calls) historical_data = { "AAPL": { "2023-10-26": {"open": 170.00, "high": 171.50, "low": 168.75, "close": 170.45}, "2023-10-27": {"open": 171.00, "high": 172.00, "low": 169.50, "close": 171.75}, # ... more historical data }, "GOOG": { "2023-10-26": {"open": 130.00, "high": 131.50, "low": 128.75, "close": 130.45}, "2023-10-27": {"open": 131.00, "high": 132.00, "low": 129.50, "close": 131.75}, # ... more historical data } } # Mock real-time prices (replace with a real-time data feed) realtime_prices = { "AAPL": 172.50, "GOOG": 132.25, "MSFT": 330.00 } # --- MCP Server Logic --- async def handle_client(websocket, path): """Handles a client connection.""" try: async for message in websocket: try: request = json.loads(message) print(f"Received request: {request}") request_type = request.get("type") if request_type == "get_price": symbol = request.get("symbol") if symbol in realtime_prices: response = {"type": "price", "symbol": symbol, "price": realtime_prices[symbol]} await websocket.send(json.dumps(response)) else: response = {"type": "error", "message": f"Symbol {symbol} not found."} await websocket.send(json.dumps(response)) elif request_type == "get_historical_data": symbol = request.get("symbol") start_date = request.get("start_date") end_date = request.get("end_date") if symbol in historical_data: # Basic date filtering (improve this for real-world use) filtered_data = { date: data for date, data in historical_data[symbol].items() if start_date <= date <= end_date } response = {"type": "historical_data", "symbol": symbol, "data": filtered_data} await websocket.send(json.dumps(response)) else: response = {"type": "error", "message": f"Symbol {symbol} not found."} await websocket.send(json.dumps(response)) elif request_type == "subscribe_price": # Simulate price updates (replace with a real-time feed integration) symbol = request.get("symbol") if symbol in realtime_prices: while True: # Simulate price change realtime_prices[symbol] += (random.random() - 0.5) * 0.1 # Small random change response = {"type": "price_update", "symbol": symbol, "price": realtime_prices[symbol]} await websocket.send(json.dumps(response)) await asyncio.sleep(1) # Send update every 1 second else: response = {"type": "error", "message": f"Symbol {symbol} not found."} await websocket.send(json.dumps(response)) else: response = {"type": "error", "message": "Invalid request type."} await websocket.send(json.dumps(response)) except json.JSONDecodeError: response = {"type": "error", "message": "Invalid JSON format."} await websocket.send(json.dumps(response)) except websockets.exceptions.ConnectionClosedError as e: print(f"Connection closed: {e}") except Exception as e: print(f"Error handling client: {e}") # --- Main --- async def main(): """Starts the WebSocket server.""" import random # Import here for use in subscribe_price start_server = websockets.serve(handle_client, "localhost", 8765) # Host and port print("MCP Server started on ws://localhost:8765") await start_server await asyncio.Future() # Run forever if __name__ == "__main__": asyncio.run(main()) ``` **Key Concepts and Explanations:** * **MCP (Market Connectivity Platform):** A system that provides access to market data (prices, historical data, news, etc.) from various sources. It acts as a central point for clients to connect and retrieve information. The goal is to abstract away the complexities of dealing with multiple data vendors and protocols. * **Data Sources:** The example uses mock data. In a real system, you would integrate with: * **Real-time Data Feeds:** Bloomberg, Refinitiv, IEX, Polygon.io, etc. These provide streaming prices. You'll need to handle their specific APIs and protocols (often proprietary). * **Historical Data Providers:** The same vendors often provide historical data. You might also use databases or specialized historical data services. * **WebSocket Server (using `websockets` library):** WebSockets provide a persistent, bidirectional communication channel between the server and clients. This is ideal for real-time data updates. * **JSON (JavaScript Object Notation):** A common format for exchanging data between the server and clients. It's human-readable and easy to parse. * **Request Handling (`handle_client` function):** * Receives JSON messages from clients. * Parses the `type` field to determine the requested action (e.g., `get_price`, `get_historical_data`, `subscribe_price`). * Retrieves data from the appropriate data source. * Formats the response as JSON and sends it back to the client. * Includes error handling. * **Request Types:** * `get_price`: Retrieves the current price for a given symbol. * `get_historical_data`: Retrieves historical price data for a given symbol within a specified date range. * `subscribe_price`: Subscribes to real-time price updates for a symbol. The server will push updates to the client whenever the price changes. * **Error Handling:** The server should handle errors gracefully and provide informative error messages to the client. * **Asynchronous Programming (using `asyncio`):** `asyncio` allows the server to handle multiple client connections concurrently without blocking. This is essential for performance. **How to Run the Example:** 1. **Install `websockets`:** ```bash pip install websockets ``` 2. **Save the code:** Save the code as a Python file (e.g., `mcp_server.py`). 3. **Run the server:** ```bash python mcp_server.py ``` 4. **Create a client:** You'll need to write a client application (in Python, JavaScript, or another language) to connect to the server and send requests. Here's a simple Python client example: ```python # Simple MCP Client (Python) import asyncio import websockets import json async def connect_and_request(): uri = "ws://localhost:8765" async with websockets.connect(uri) as websocket: # Example 1: Get current price request1 = {"type": "get_price", "symbol": "AAPL"} await websocket.send(json.dumps(request1)) response1 = await websocket.recv() print(f"Received: {response1}") # Example 2: Get historical data request2 = {"type": "get_historical_data", "symbol": "AAPL", "start_date": "2023-10-26", "end_date": "2023-10-27"} await websocket.send(json.dumps(request2)) response2 = await websocket.recv() print(f"Received: {response2}") # Example 3: Subscribe to price updates request3 = {"type": "subscribe_price", "symbol": "GOOG"} await websocket.send(json.dumps(request3)) for _ in range(5): # Receive 5 updates response3 = await websocket.recv() print(f"Received price update: {response3}") await asyncio.sleep(0.5) # Wait a bit if __name__ == "__main__": asyncio.run(connect_and_request()) ``` Save this client code as `mcp_client.py` and run it in a separate terminal: ```bash python mcp_client.py ``` **Important Considerations for a Real-World MCP:** * **Authentication and Authorization:** Implement security measures to control access to the data. Clients should authenticate themselves, and the server should authorize them to access specific data feeds. * **Data Normalization:** Data from different vendors may have different formats and conventions. Normalize the data into a consistent format before providing it to clients. * **Error Handling and Resilience:** Implement robust error handling to deal with data feed outages, network problems, and other issues. Consider using retry mechanisms and failover strategies. * **Scalability:** Design the MCP to handle a large number of concurrent client connections and high data volumes. Consider using load balancing and distributed caching. * **Data Caching:** Cache frequently accessed data to improve performance and reduce the load on data sources. * **API Design:** Design a clear and well-documented API for clients to access the data. Consider using RESTful APIs or GraphQL in addition to WebSockets. * **Monitoring and Logging:** Implement monitoring and logging to track the performance of the MCP and identify potential problems. * **Data Quality:** Implement data quality checks to ensure the accuracy and completeness of the data. * **Protocol Support:** Support multiple protocols (e.g., FIX, WebSocket, REST) to accommodate different client requirements. * **Entitlements:** Manage data entitlements to ensure that clients only have access to the data they are authorized to receive. This is often tied to licensing agreements with data vendors. * **Market Data Standards:** Consider using industry-standard market data formats and protocols (e.g., FIX/FAST). This example provides a basic foundation for building an MCP server. You'll need to expand upon it to meet the specific requirements of your application. Remember to replace the mock data with real data feeds and implement the necessary security, error handling, and scalability features. **Tradução para Português:** Aqui está um exemplo de um servidor MCP (Market Connectivity Platform - Plataforma de Conectividade de Mercado) para preços de títulos, informações históricas, etc.: (Observação: Este é um esboço conceitual. Construir um servidor MCP completo requer um esforço de desenvolvimento significativo e depende muito das tecnologias e protocolos específicos que você pretende suportar.) ```python # Servidor MCP Conceitual (Exemplo em Python) import asyncio import websockets import json import datetime # --- Fontes de Dados (Substitua por feeds de dados reais) --- # Dados históricos simulados (substitua por banco de dados ou chamadas de API) historical_data = { "AAPL": { "2023-10-26": {"open": 170.00, "high": 171.50, "low": 168.75, "close": 170.45}, "2023-10-27": {"open": 171.00, "high": 172.00, "low": 169.50, "close": 171.75}, # ... mais dados históricos }, "GOOG": { "2023-10-26": {"open": 130.00, "high": 131.50, "low": 128.75, "close": 130.45}, "2023-10-27": {"open": 131.00, "high": 132.00, "low": 129.50, "close": 131.75}, # ... mais dados históricos } } # Preços em tempo real simulados (substitua por um feed de dados em tempo real) realtime_prices = { "AAPL": 172.50, "GOOG": 132.25, "MSFT": 330.00 } # --- Lógica do Servidor MCP --- async def handle_client(websocket, path): """Lida com uma conexão de cliente.""" try: async for message in websocket: try: request = json.loads(message) print(f"Requisição recebida: {request}") request_type = request.get("type") if request_type == "get_price": symbol = request.get("symbol") if symbol in realtime_prices: response = {"type": "price", "symbol": symbol, "price": realtime_prices[symbol]} await websocket.send(json.dumps(response)) else: response = {"type": "error", "message": f"Símbolo {symbol} não encontrado."} await websocket.send(json.dumps(response)) elif request_type == "get_historical_data": symbol = request.get("symbol") start_date = request.get("start_date") end_date = request.get("end_date") if symbol in historical_data: # Filtragem básica de datas (melhore isso para uso no mundo real) filtered_data = { date: data for date, data in historical_data[symbol].items() if start_date <= date <= end_date } response = {"type": "historical_data", "symbol": symbol, "data": filtered_data} await websocket.send(json.dumps(response)) else: response = {"type": "error", "message": f"Símbolo {symbol} não encontrado."} await websocket.send(json.dumps(response)) elif request_type == "subscribe_price": # Simula atualizações de preços (substitua por uma integração de feed em tempo real) symbol = request.get("symbol") if symbol in realtime_prices: while True: # Simula mudança de preço realtime_prices[symbol] += (random.random() - 0.5) * 0.1 # Pequena mudança aleatória response = {"type": "price_update", "symbol": symbol, "price": realtime_prices[symbol]} await websocket.send(json.dumps(response)) await asyncio.sleep(1) # Envia atualização a cada 1 segundo else: response = {"type": "error", "message": f"Símbolo {symbol} não encontrado."} await websocket.send(json.dumps(response)) else: response = {"type": "error", "message": "Tipo de requisição inválido."} await websocket.send(json.dumps(response)) except json.JSONDecodeError: response = {"type": "error", "message": "Formato JSON inválido."} await websocket.send(json.dumps(response)) except websockets.exceptions.ConnectionClosedError as e: print(f"Conexão fechada: {e}") except Exception as e: print(f"Erro ao lidar com o cliente: {e}") # --- Principal --- async def main(): """Inicia o servidor WebSocket.""" import random # Importe aqui para usar em subscribe_price start_server = websockets.serve(handle_client, "localhost", 8765) # Host e porta print("Servidor MCP iniciado em ws://localhost:8765") await start_server await asyncio.Future() # Executa para sempre if __name__ == "__main__": asyncio.run(main()) ``` **Conceitos Chave e Explicações:** * **MCP (Market Connectivity Platform - Plataforma de Conectividade de Mercado):** Um sistema que fornece acesso a dados de mercado (preços, dados históricos, notícias, etc.) de várias fontes. Ele atua como um ponto central para os clientes se conectarem e recuperarem informações. O objetivo é abstrair as complexidades de lidar com vários fornecedores de dados e protocolos. * **Fontes de Dados:** O exemplo usa dados simulados. Em um sistema real, você integraria com: * **Feeds de Dados em Tempo Real:** Bloomberg, Refinitiv, IEX, Polygon.io, etc. Estes fornecem preços de streaming. Você precisará lidar com suas APIs e protocolos específicos (geralmente proprietários). * **Provedores de Dados Históricos:** Os mesmos fornecedores geralmente fornecem dados históricos. Você também pode usar bancos de dados ou serviços especializados de dados históricos. * **Servidor WebSocket (usando a biblioteca `websockets`):** WebSockets fornecem um canal de comunicação persistente e bidirecional entre o servidor e os clientes. Isso é ideal para atualizações de dados em tempo real. * **JSON (JavaScript Object Notation):** Um formato comum para trocar dados entre o servidor e os clientes. É legível por humanos e fácil de analisar. * **Tratamento de Requisições (função `handle_client`):** * Recebe mensagens JSON dos clientes. * Analisa o campo `type` para determinar a ação solicitada (por exemplo, `get_price`, `get_historical_data`, `subscribe_price`). * Recupera dados da fonte de dados apropriada. * Formata a resposta como JSON e a envia de volta ao cliente. * Inclui tratamento de erros. * **Tipos de Requisição:** * `get_price`: Recupera o preço atual para um determinado símbolo. * `get_historical_data`: Recupera dados históricos de preços para um determinado símbolo dentro de um intervalo de datas especificado. * `subscribe_price`: Assina atualizações de preços em tempo real para um símbolo. O servidor enviará atualizações para o cliente sempre que o preço mudar. * **Tratamento de Erros:** O servidor deve lidar com erros de forma elegante e fornecer mensagens de erro informativas ao cliente. * **Programação Assíncrona (usando `asyncio`):** `asyncio` permite que o servidor lide com várias conexões de clientes simultaneamente sem bloquear. Isso é essencial para o desempenho. **Como Executar o Exemplo:** 1. **Instale `websockets`:** ```bash pip install websockets ``` 2. **Salve o código:** Salve o código como um arquivo Python (por exemplo, `mcp_server.py`). 3. **Execute o servidor:** ```bash python mcp_server.py ``` 4. **Crie um cliente:** Você precisará escrever um aplicativo cliente (em Python, JavaScript ou outra linguagem) para se conectar ao servidor e enviar requisições. Aqui está um exemplo simples de cliente Python: ```python # Cliente MCP Simples (Python) import asyncio import websockets import json async def connect_and_request(): uri = "ws://localhost:8765" async with websockets.connect(uri) as websocket: # Exemplo 1: Obter preço atual request1 = {"type": "get_price", "symbol": "AAPL"} await websocket.send(json.dumps(request1)) response1 = await websocket.recv() print(f"Recebido: {response1}") # Exemplo 2: Obter dados históricos request2 = {"type": "get_historical_data", "symbol": "AAPL", "start_date": "2023-10-26", "end_date": "2023-10-27"} await websocket.send(json.dumps(request2)) response2 = await websocket.recv() print(f"Recebido: {response2}") # Exemplo 3: Assinar atualizações de preços request3 = {"type": "subscribe_price", "symbol": "GOOG"} await websocket.send(json.dumps(request3)) for _ in range(5): # Receber 5 atualizações response3 = await websocket.recv() print(f"Atualização de preço recebida: {response3}") await asyncio.sleep(0.5) # Esperar um pouco if __name__ == "__main__": asyncio.run(connect_and_request()) ``` Salve este código do cliente como `mcp_client.py` e execute-o em um terminal separado: ```bash python mcp_client.py ``` **Considerações Importantes para um MCP no Mundo Real:** * **Autenticação e Autorização:** Implemente medidas de segurança para controlar o acesso aos dados. Os clientes devem se autenticar e o servidor deve autorizá-los a acessar feeds de dados específicos. * **Normalização de Dados:** Os dados de diferentes fornecedores podem ter formatos e convenções diferentes. Normalize os dados em um formato consistente antes de fornecê-los aos clientes. * **Tratamento de Erros e Resiliência:** Implemente um tratamento de erros robusto para lidar com interrupções de feeds de dados, problemas de rede e outros problemas. Considere o uso de mecanismos de repetição e estratégias de failover. * **Escalabilidade:** Projete o MCP para lidar com um grande número de conexões de clientes simultâneas e altos volumes de dados. Considere o uso de balanceamento de carga e cache distribuído. * **Cache de Dados:** Armazene em cache os dados acessados ​​com frequência para melhorar o desempenho e reduzir a carga nas fontes de dados. * **Design de API:** Projete uma API clara e bem documentada para os clientes acessarem os dados. Considere o uso de APIs RESTful ou GraphQL, além de WebSockets. * **Monitoramento e Registro:** Implemente monitoramento e registro para rastrear o desempenho do MCP e identificar problemas potenciais. * **Qualidade dos Dados:** Implemente verificações de qualidade dos dados para garantir a precisão e integridade dos dados. * **Suporte a Protocolos:** Suporte a vários protocolos (por exemplo, FIX, WebSocket, REST) para acomodar diferentes requisitos do cliente. * **Entitlements (Direitos):** Gerencie os direitos de dados para garantir que os clientes tenham acesso apenas aos dados que estão autorizados a receber. Isso geralmente está vinculado a acordos de licenciamento com fornecedores de dados. * **Padrões de Dados de Mercado:** Considere o uso de formatos e protocolos de dados de mercado padrão do setor (por exemplo, FIX/FAST). Este exemplo fornece uma base básica para a construção de um servidor MCP. Você precisará expandi-lo para atender aos requisitos específicos de sua aplicação. Lembre-se de substituir os dados simulados por feeds de dados reais e implementar os recursos de segurança, tratamento de erros e escalabilidade necessários.

Modular MCP Server

A scalable, auto-discovering Model Context Protocol server that dynamically loads tools from the tools directory, enabling LLMs to access various capabilities through a standardized interface.

AI Develop Assistant

Assists AI developers with intelligent requirement analysis and architecture design through guided clarification questions, branch-aware management, and automated architecture generation with persistent storage.

Hugging Face Hub Semantic Search MCP

An unofficial MCP server that provides semantic search capabilities for Hugging Face models and datasets, enabling Claude and other MCP-compatible clients to search, discover, and explore the Hugging Face ecosystem using natural language queries.

Awesome MCP ZH

Seleção de recursos MCP, Guia MCP, Claude MCP, Servidores MCP, Clientes MCP

aptos-dex-mcp

MCP server for Dex on Aptos

ML Lab MCP

Transforms AI assistants into a full ML engineering environment for training and fine-tuning models across multiple backends (local GPU, Mistral, Together AI, OpenAI) and cloud providers (Lambda Labs, RunPod, SSH-accessible VPS), with dataset management, experiment tracking, cost estimation, and deployment to Ollama/Open WebUI.

beeper-mcp

Um serviço de backend para executar transações Beeper na Binance Smart Chain.

MCP Server for ElevenLabs

A Model Context Protocol server for ElevenLabs conversational agents that enables them to search the web, get weather information, and perform calculations.

Tavus MCP Server

Enables AI video generation, replica management, conversational AI, lipsync, and speech synthesis through the Tavus API. Provides 29 tools across Phoenix replicas, video generation, personas, lipsync, and text-to-speech capabilities.

AWS Athena MCP Server

A Model Context Protocol server that enables SQL queries and database exploration in AWS Athena through a standardized interface.

Dart

Um servidor de Protocolo de Contexto de Modelo de IA oficial que permite que assistentes de IA interajam com o gerenciamento de projetos Dart, criando/gerenciando tarefas e documentos por meio de prompts e ferramentas.

CashChat MCP Server

Connects CashChat financial data to AI assistants, enabling users to manage transactions, view spending summaries, and track category breakdowns through natural language. It supports both local stdio and remote URL-based connections with secure OAuth 2.0 authentication.

Saffron MCP Server

Enables AI assistants to interact with Saffron recipe management functionality, including creating and updating recipes, importing from websites or text, and organizing cookbooks. Provides comprehensive recipe management capabilities through Saffron's API with support for ingredients, instructions, timing, and metadata.

mcp-mifosx

Integrar o Servidor MCP para Mifos X, uma Solução de Core Banking de Código Aberto para Instituições Financeiras. Útil para gerenciar clientes, empréstimos, poupanças, ações, transações financeiras e gerar relatórios financeiros.

Help Scout MCP Server

Connects Claude and other AI assistants to Help Scout customer support data with advanced search capabilities, conversation analysis, and enterprise-grade security features including PII redaction.

Punjab Technical Education MCP Server

This MCP server enables interaction with the Punjab State Board of Technical Education and Industrial Training API, allowing access to technical education services and information through natural language.

MCP SVG Converter

Um servidor de Protocolo de Contexto de Modelo que fornece ferramentas para converter código SVG em imagens PNG e JPG de alta qualidade com opções de personalização detalhadas.

Sigma MCP Server

Enables users to interact with the Sigma Computing API to analyze documents and manage analytics data via a serverless AWS architecture. It features document search and analytics capabilities with DynamoDB-backed caching for optimized performance.

Enhanced Fetch MCP

Provides advanced web scraping with HTTP client, smart content extraction to Markdown, browser automation via Playwright, screenshot/PDF generation, and Docker sandbox execution environments.

Weather MCP Server

Enables AI assistants to fetch current weather conditions and forecasts for any city using the Open-Meteo API. Provides temperature, precipitation, and hourly forecast data through natural language queries.

Alpic MCP Template

A TypeScript template for building MCP servers with HTTP transport that provides a foundation for creating integrations between AI assistants and custom tools. Includes example implementations and development tooling to help developers create their own MCP servers.