Discover Awesome MCP Servers

Mindmap MCP Server

Sebuah server Protokol Konteks Model yang mengubah konten Markdown menjadi peta pikiran interaktif, memungkinkan asisten AI untuk memvisualisasikan informasi hierarkis melalui konten HTML atau file yang disimpan.

Prem MCP Server

Implementasi server Model Context Protocol yang memungkinkan integrasi tanpa hambatan dengan Claude dan klien yang kompatibel dengan MCP lainnya untuk mengakses model bahasa Prem AI, kemampuan RAG, dan fitur manajemen dokumen.

Frappe MCP Server

A server that implements the Anthropic Model Control Protocol (MCP) server for accessing Frappe.

GitHub Actions MCP Server

Sebuah server MCP yang memungkinkan asisten AI untuk mengelola alur kerja GitHub Actions dengan menyediakan alat untuk mendaftar, melihat, memicu, membatalkan, dan menjalankan ulang alur kerja melalui GitHub API.

ExMCP Test ServerExMCP Test Server Summary

Test implementation of mcp server in Elixir

Sanity MCP server

Sanity MCP Server

OpenAI Speech-to-Text transcriptions MCP Server

Sebuah server MCP yang memungkinkan transkripsi berkas audio menggunakan API Speech-to-Text OpenAI, dengan dukungan untuk berbagai bahasa dan opsi penyimpanan berkas.

Awesome MCP Servers

Server MCP Keren - Daftar server Model Context Protocol yang dikurasi

StrongApps_MCPE_servers

Cermin dari

mysqldb-mcp-server MCP server

Sebuah server MCP yang memungkinkan integrasi database MySQL dengan Claude. Anda dapat menjalankan kueri SQL dan mengelola koneksi database.

Inbox Zero AI MCP

Sebuah MCP yang membantu Anda mengelola email Anda. Misalnya, untuk mengetahui email mana yang memerlukan balasan atau tindak lanjut. Menawarkan fungsionalitas yang lebih dari sekadar fungsionalitas dasar Gmail.

Raygun MCP Server

Mirror of

Sequential Thinking MCP Server

Sebuah server MCP yang memungkinkan pemecahan masalah dinamis dan reflektif dengan menyusun proses berpikir dan secara otomatis mencatat setiap sesi ke Recall.

Multichain MCP Server 🌐

A MCP Server Route Hub connecting all MCP Servers

JetBrains MCP Proxy Server

Server ini memproksi permintaan dari klien ke JetBrains IDE.

claude_mcp

Different MCP servers in Python

Tinypng Mcp Server

Okay, here's how you would generally use TinyPNG via MCP (assuming MCP refers to the Mod Coder Pack, a tool for decompiling, modifying, and recompiling Minecraft code): **Understanding the Context** * **TinyPNG:** TinyPNG is a service that uses lossy compression techniques to reduce the file size of PNG images, often significantly, while maintaining acceptable visual quality. This is very useful for Minecraft modding because smaller textures mean smaller mod file sizes and potentially better performance in-game. * **MCP (Mod Coder Pack):** MCP is a toolset that allows you to decompile Minecraft's code, make modifications, and then recompile it. It's essential for creating mods that change the core game. * **The Goal:** You want to integrate TinyPNG's compression into your mod development workflow, likely to automatically optimize textures before packaging your mod. **General Approach (Conceptual - Requires Coding)** You can't directly "use TinyPNG via MCP" in the sense of a built-in feature. MCP doesn't have native TinyPNG integration. You'll need to write code (likely in Java, since that's what Minecraft mods use) to interact with the TinyPNG API and integrate it into your build process. Here's a breakdown of the steps: 1. **Get a TinyPNG API Key:** * Go to the TinyPNG developer website ([https://tinypng.com/developers](https://tinypng.com/developers)) and sign up for an API key. You'll need this to authenticate your requests to the TinyPNG service. 2. **Add a TinyPNG API Library to Your Project:** * You'll need a Java library that simplifies making HTTP requests to the TinyPNG API. There are a few options: * **Official TinyPNG Java Library:** TinyPNG provides an official Java library. This is the recommended approach. You can find it on their website or through Maven/Gradle. * **Other HTTP Libraries:** You could use a general-purpose HTTP client library like Apache HttpClient or OkHttp, but you'll have to handle the API request formatting and response parsing yourself. The official library is much easier. 3. **Write Java Code to Compress Images:** * Create a Java class (or integrate it into an existing one) that uses the TinyPNG API library to compress your PNG images. Here's a simplified example (using the *concept* of what the official library might look like - check the actual library documentation for the correct usage): ```java import com.tinify.Tinify; import java.io.IOException; import java.nio.file.Files; import java.nio.file.Path; import java.nio.file.Paths; public class TinyPNGCompressor { private static final String TINYPNG_API_KEY = "YOUR_TINYPNG_API_KEY"; // Replace with your actual key public static void compressImage(String inputImagePath, String outputImagePath) { Tinify.setKey(TINYPNG_API_KEY); try { Path inputPath = Paths.get(inputImagePath); Path outputPath = Paths.get(outputImagePath); // Ensure the output directory exists Files.createDirectories(outputPath.getParent()); Tinify.fromFile(inputImagePath).toFile(outputImagePath); System.out.println("Compressed " + inputImagePath + " to " + outputImagePath); } catch (IOException e) { System.err.println("Error compressing " + inputImagePath + ": " + e.getMessage()); e.printStackTrace(); } } public static void main(String[] args) { // Example usage: compressImage("path/to/your/input.png", "path/to/your/output.png"); } } ``` * **Important:** Replace `"YOUR_TINYPNG_API_KEY"` with your actual API key. * **Error Handling:** The code includes basic error handling (try-catch blocks). You should improve this to handle API rate limits, network errors, and other potential issues gracefully. * **Output Path:** The `outputImagePath` can be the same as the `inputImagePath` to overwrite the original file, or you can specify a different path to keep the original. 4. **Integrate into Your Build Process (build.gradle or similar):** * This is the key part. You need to integrate the TinyPNG compression into your mod's build process. This usually involves modifying your `build.gradle` (if you're using Gradle) or your Ant build script (if you're using Ant). * **Gradle Example (Conceptual):** ```gradle plugins { id 'java' } dependencies { // Add the TinyPNG Java library as a dependency implementation 'com.tinify:tinify:1.6.0' // Replace with the actual version } task compressTextures { doLast { // Find all PNG files in your textures directory fileTree('src/main/resources/assets/yourmodid/textures').include('**/*.png').each { file -> // Call your TinyPNG compression function println "Compressing: " + file.absolutePath javaexec { main = 'TinyPNGCompressor' // Your Java class name classpath = sourceSets.main.runtimeClasspath args = [file.absolutePath, file.absolutePath] // Input and output paths (overwrite) } } } } // Make sure the compressTextures task runs before the jar task jar.dependsOn compressTextures ``` * **Explanation:** * `implementation 'com.tinify:tinify:1.6.0'` adds the TinyPNG library as a dependency. Replace `1.6.0` with the actual version number. * The `compressTextures` task finds all PNG files in your texture directory. Adjust the path (`'src/main/resources/assets/yourmodid/textures'`) to match your mod's texture location. * `javaexec` runs your `TinyPNGCompressor` class, passing the input and output file paths as arguments. * `jar.dependsOn compressTextures` ensures that the `compressTextures` task runs *before* the `jar` task (which creates your mod's JAR file). This means your textures will be compressed before the mod is packaged. * **Ant Example (Conceptual):** If you're using Ant, you'll need to use the `<java>` task to execute your `TinyPNGCompressor` class within your Ant build script. The logic is similar to the Gradle example. 5. **Run Your Build:** * Run your Gradle build (e.g., `./gradlew build`) or your Ant build. The `compressTextures` task (or its Ant equivalent) should run, compressing your textures before the mod is packaged. **Important Considerations:** * **API Usage Limits:** TinyPNG has API usage limits (a certain number of free compressions per month). If you exceed the limit, you'll need to pay for additional compressions. Handle API errors and rate limits gracefully in your code. * **Lossy Compression:** TinyPNG uses lossy compression. This means some image quality will be lost. Experiment with different settings (if the TinyPNG API allows it) to find a balance between file size and visual quality. For some textures, the loss might be imperceptible, while for others, it might be noticeable. * **Backup Your Textures:** Before running the compression, it's a good idea to back up your original textures in case you're not happy with the results. * **Alternative Tools:** There are other image optimization tools besides TinyPNG. Some are command-line tools that you could also integrate into your build process. Research and choose the tool that best suits your needs. * **MCP Updates:** MCP is updated periodically. Make sure your code is compatible with the version of MCP you're using. * **Modding Community:** Check the Minecraft modding community forums and resources. Someone may have already created a similar solution or have helpful tips. **In summary, integrating TinyPNG into your MCP-based mod development requires writing Java code to interact with the TinyPNG API and then integrating that code into your build process (Gradle or Ant). The provided examples are conceptual; you'll need to adapt them to your specific project structure and the TinyPNG API library you choose.**

MCP API Connect

MCP server that enables MCP to make REST API calls

Favicon MCP Server

A MCP server for converting input images into favicon

NEAR MCP

Okay, here's how you can interact with the NEAR blockchain through MCP (Meta-Consensus Protocol) calls, along with explanations and considerations: **Understanding MCP (Meta-Consensus Protocol)** MCP is a core component of the NEAR blockchain's architecture. It's essentially the mechanism that allows different shards (parallel blockchains within NEAR) to communicate and coordinate with each other. It's what enables cross-shard transactions and data sharing. **How MCP Calls Work (Simplified)** 1. **Initiation:** A transaction on one shard (Shard A) needs to interact with a contract or data on another shard (Shard B). This transaction initiates an MCP call. 2. **Message Passing:** The transaction on Shard A creates a message that contains the details of the desired interaction (e.g., function call, data transfer). This message is routed through the MCP layer. 3. **Cross-Shard Communication:** The MCP layer ensures that the message is reliably delivered to Shard B. 4. **Execution on Target Shard:** Shard B receives the message and executes the requested action (e.g., calls a function on a contract). 5. **Response (Optional):** If the interaction requires a response, Shard B sends a message back to Shard A through the MCP layer. 6. **Completion:** Shard A receives the response (if any) and completes the original transaction. **Key Considerations When Using MCP Calls** * **Asynchronous Nature:** MCP calls are inherently asynchronous. This means that the original transaction that initiates the call doesn't immediately receive the result. You need to design your contracts to handle this asynchronous behavior. You'll typically use callbacks or other mechanisms to process the results when they become available. * **Gas Costs:** Cross-shard calls are generally more expensive in terms of gas than intra-shard calls (calls within the same shard). This is because they involve more complex communication and coordination. * **Complexity:** Developing contracts that rely on MCP calls can be more complex than developing single-shard contracts. You need to carefully manage the state and handle potential errors that can occur during cross-shard communication. * **Security:** Cross-shard communication introduces additional security considerations. You need to ensure that the messages being passed between shards are properly authenticated and authorized to prevent malicious actors from exploiting vulnerabilities. **How to Implement MCP Calls (Example using `near-sdk-rs`)** While you don't directly "call" MCP, you use the NEAR SDK to create contracts that leverage the underlying MCP functionality for cross-shard communication. Here's a simplified example using Rust and `near-sdk-rs`: **Contract A (on Shard A):** ```rust use near_sdk::borsh::{self, BorshDeserialize, BorshSerialize}; use near_sdk::collections::UnorderedMap; use near_sdk::json_types::U128; use near_sdk::{env, near_bindgen, AccountId, Promise, PromiseResult}; #[near_bindgen] #[derive(BorshDeserialize, BorshSerialize, PanicOnDefault)] pub struct ContractA { owner_id: AccountId, data: UnorderedMap<String, String>, } #[near_bindgen] impl ContractA { #[init] pub fn new(owner_id: AccountId) -> Self { Self { owner_id, data: UnorderedMap::new(b"data".to_vec()), } } pub fn set_data(&mut self, key: String, value: String) { self.data.insert(&key, &value); } pub fn get_data(&self, key: String) -> Option<String> { self.data.get(&key) } // Function to call Contract B on another shard pub fn call_contract_b(&self, contract_b_account_id: AccountId, key: String) -> Promise { // Construct the arguments for the function call on Contract B let args = near_sdk::serde_json::json!({ "key": key, "value": "some_value_from_a".to_string(), }).to_string().into_bytes(); // Call the `set_data` function on Contract B Promise::new(contract_b_account_id) .function_call( "set_data".to_string(), // Function name on Contract B args, // Arguments for the function call 0, // Attached deposit (in yoctoNEAR) 50_000_000_000_000, // Gas attached (adjust as needed) ) .then(Self::callback_after_call_b(env::current_account_id())) } // Callback function to handle the result of the call to Contract B #[private] pub fn callback_after_call_b(caller_account_id: AccountId) -> Promise { near_sdk::log!("Callback from Contract B received"); match env::promise_result(0) { PromiseResult::Successful(_result) => { near_sdk::log!("Call to Contract B was successful"); // Optionally, process the result from Contract B here Promise::new(caller_account_id).function_call( "process_result".to_string(), near_sdk::serde_json::json!({}).to_string().into_bytes(), 0, 50_000_000_000_000, ) } PromiseResult::Failed => { near_sdk::log!("Call to Contract B failed"); // Handle the failure appropriately Promise::new(caller_account_id).function_call( "handle_failure".to_string(), near_sdk::serde_json::json!({}).to_string().into_bytes(), 0, 50_000_000_000_000, ) } PromiseResult::NotReady => { near_sdk::log!("Call to Contract B is not ready yet"); Promise::new(caller_account_id).function_call( "retry_call".to_string(), near_sdk::serde_json::json!({}).to_string().into_bytes(), 0, 50_000_000_000_000, ) } } } #[private] pub fn process_result(&mut self) { near_sdk::log!("Processing result from Contract B"); } #[private] pub fn handle_failure(&mut self) { near_sdk::log!("Handling failure from Contract B"); } #[private] pub fn retry_call(&mut self) { near_sdk::log!("Retrying call to Contract B"); } } ``` **Contract B (on Shard B):** ```rust use near_sdk::borsh::{self, BorshDeserialize, BorshSerialize}; use near_sdk::collections::UnorderedMap; use near_sdk::{env, near_bindgen, AccountId}; #[near_bindgen] #[derive(BorshDeserialize, BorshSerialize, PanicOnDefault)] pub struct ContractB { owner_id: AccountId, data: UnorderedMap<String, String>, } #[near_bindgen] impl ContractB { #[init] pub fn new(owner_id: AccountId) -> Self { Self { owner_id, data: UnorderedMap::new(b"data".to_vec()), } } pub fn set_data(&mut self, key: String, value: String) { near_sdk::log!("Contract B received key: {}, value: {}", key, value); self.data.insert(&key, &value); } pub fn get_data(&self, key: String) -> Option<String> { self.data.get(&key) } } ``` **Explanation:** 1. **`call_contract_b` (Contract A):** * This function initiates the cross-shard call. * `contract_b_account_id`: The account ID of Contract B (on the other shard). * `args`: The arguments to be passed to the `set_data` function on Contract B. We use `serde_json` to serialize the arguments into a JSON string. * `Promise::new(...)`: Creates a new promise to call the function on Contract B. * `function_call(...)`: Specifies the function to call (`set_data`), the arguments, the attached deposit (0 in this case), and the gas attached. **Important:** Allocate sufficient gas for the cross-shard call. * `.then(Self::callback_after_call_b(...))`: Attaches a callback function (`callback_after_call_b`) to handle the result of the call to Contract B. This is crucial because the call is asynchronous. 2. **`callback_after_call_b` (Contract A):** * This function is executed *after* the call to Contract B has completed (either successfully or with an error). * `env::promise_result(0)`: Retrieves the result of the promise (the call to Contract B). * `PromiseResult::Successful(_result)`: If the call was successful, you can access the result (if any) from Contract B. * `PromiseResult::Failed`: If the call failed, you need to handle the error appropriately (e.g., retry, log the error, revert the transaction). * `PromiseResult::NotReady`: If the call is not ready yet, you can retry the call. 3. **`set_data` (Contract B):** * This is the function that is called on Contract B. * It receives the `key` and `value` from Contract A. * It stores the data in its own `data` map. **Deployment and Testing:** 1. **Deploy Contract A to one shard.** 2. **Deploy Contract B to a *different* shard.** This is essential for testing cross-shard communication. 3. **Call `call_contract_b` on Contract A**, providing the account ID of Contract B. 4. **Observe the logs:** You should see logs from both Contract A and Contract B, indicating that the cross-shard call was initiated, executed, and the callback was handled. **Important Notes:** * **Gas Allocation:** Carefully estimate and allocate sufficient gas for cross-shard calls. Insufficient gas will cause the transaction to fail. You can use the NEAR CLI to simulate transactions and estimate gas costs. * **Error Handling:** Implement robust error handling in your contracts to deal with potential failures during cross-shard communication. * **Security Audits:** If you are building critical applications that rely on cross-shard communication, consider having your contracts audited by security professionals. * **NEAR Documentation:** Refer to the official NEAR documentation for the most up-to-date information on cross-shard communication and MCP: [https://docs.near.org/](https://docs.near.org/) **In summary, you don't directly "call" MCP. You use the NEAR SDK to create contracts that leverage the underlying MCP functionality for cross-shard communication. The key is to use `Promise` and `then` to handle the asynchronous nature of cross-shard calls and to implement proper error handling.** Let me know if you have any more specific questions or scenarios you'd like to explore!

Plane MCP Server

Sebuah server Protokol Konteks Model yang memungkinkan LLM (Model Bahasa Besar) untuk berinteraksi dengan Plane.so, memungkinkan mereka untuk mengelola proyek dan isu melalui API Plane untuk alur kerja manajemen proyek yang efisien.

Oss Mcp

Server Protokol Konteks Model yang memungkinkan model bahasa besar untuk mengunggah file langsung ke Alibaba Cloud Object Storage Service (OSS), mendukung beberapa konfigurasi OSS dan direktori unggah yang ditentukan.

Obsidian MCP Server

Mirror of