Discover Awesome MCP Servers

OpenTargets MCP Server

Unofficial Model Context Protocol server for accessing Open Targets platform data for gene-drug-disease associations research.

Awesome MCP Servers

Koleksi lengkap server Model Context Protocol (MCP)

Reddit MCP Server

An MCP server that enables AI assistants to access and interact with Reddit content through features like user analysis, post retrieval, subreddit statistics, and authenticated posting capabilities.

Remote MCP Server Authless

A Cloudflare Workers-based Model Context Protocol server without authentication requirements, allowing users to deploy and customize AI tools that can be accessed from Claude Desktop or Cloudflare AI Playground.

uuid-mcp-server-example

Ini adalah server MCP sederhana yang membuat uuid(v4).

MCP Memory

An MCP server that enables clients like Cursor, Claude, and Windsurf to remember user information and preferences across conversations using vector search technology.

Databricks MCP Server

A Model Context Protocol server that enables AI assistants to interact with Databricks workspaces, allowing them to browse Unity Catalog, query metadata, sample data, and execute SQL queries.

MCP PDF Server

A Model Context Protocol (MCP) based server that efficiently manages PDF files, allowing AI coding tools like Cursor to read, summarize, and extract information from PDF datasheets to assist embedded development work.

Interzoid Weather City API MCP Server

An MCP server that provides access to the Interzoid GetWeatherCity API, allowing users to retrieve weather information for specified cities through natural language interactions.

Square MCP Server by CData

This read-only MCP Server allows you to connect to Square data from Claude Desktop through CData JDBC Drivers. Free (beta) read/write servers available at https://www.cdata.com/solutions/mcp

Cars MCP Server

Okay, here's a basic example of how you might set up a simple Minecraft Protocol (MCP) server using Spring AI. This is a conceptual outline and requires significant further development to be a fully functional server. It focuses on integrating Spring AI for potential AI-driven features within the server. **Important Considerations:** * **MCP Protocol Complexity:** The Minecraft protocol is complex. This example simplifies it drastically. Building a real server requires deep understanding of the protocol and handling many packet types. * **Spring AI's Role:** Spring AI is used here to *potentially* add AI-driven features. The core server functionality is separate. The example shows how you *could* integrate AI for things like responding to player commands or generating content. * **Incomplete Example:** This is a *very* basic starting point. It lacks error handling, proper packet parsing, world management, player management, and many other essential features. * **Libraries:** You'll need to add dependencies to your `pom.xml` or `build.gradle` for Spring Boot, Spring AI, and potentially a networking library like Netty (although this example uses basic Java sockets for simplicity). **Conceptual Code Example (Java with Spring Boot and Spring AI):** ```java // pom.xml (or build.gradle) - Add these dependencies // <dependency> // <groupId>org.springframework.boot</groupId> // <artifactId>spring-boot-starter-web</artifactId> // </dependency> // <dependency> // <groupId>org.springframework.ai</groupId> // <artifactId>spring-ai-openai</artifactId> // Or another AI provider // <version>0.8.0</version> // Check for the latest version // </dependency> // <dependency> // <groupId>org.springframework.boot</groupId> // <artifactId>spring-boot-starter-test</artifactId> // <scope>test</scope> // </dependency> import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.ai.client.AiClient; import org.springframework.ai.prompt.PromptTemplate; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import javax.annotation.PostConstruct; import java.io.DataInputStream; import java.io.DataOutputStream; import java.io.IOException; import java.net.ServerSocket; import java.net.Socket; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; @SpringBootApplication public class MinecraftServerApplication { public static void main(String[] args) { SpringApplication.run(MinecraftServerApplication.class, args); } } @Component class MinecraftServer { private static final int PORT = 25565; // Default Minecraft port private final ExecutorService executorService = Executors.newFixedThreadPool(10); // Thread pool for handling clients @Autowired private AiClient aiClient; // Inject Spring AI client @PostConstruct public void startServer() { try (ServerSocket serverSocket = new ServerSocket(PORT)) { System.out.println("Minecraft server started on port " + PORT); while (true) { Socket clientSocket = serverSocket.accept(); System.out.println("New client connected: " + clientSocket.getInetAddress()); executorService.submit(new ClientHandler(clientSocket, aiClient)); // Pass AI client to handler } } catch (IOException e) { System.err.println("Server exception: " + e.getMessage()); e.printStackTrace(); } } static class ClientHandler implements Runnable { private final Socket clientSocket; private final AiClient aiClient; public ClientHandler(Socket socket, AiClient aiClient) { this.clientSocket = socket; this.aiClient = aiClient; } @Override public void run() { try (DataInputStream in = new DataInputStream(clientSocket.getInputStream()); DataOutputStream out = new DataOutputStream(clientSocket.getOutputStream())) { // **VERY BASIC** handshake (simplified) int packetId = in.readUnsignedByte(); System.out.println("Received packet ID: " + packetId); if (packetId == 0x00) { // Example: Handshake packet ID // Read handshake data (protocol version, server address, port, next state) int protocolVersion = readVarInt(in); String serverAddress = readString(in); int serverPort = in.readUnsignedShort(); int nextState = in.readUnsignedByte(); System.out.println("Handshake: Protocol " + protocolVersion + ", Address " + serverAddress + ", Port " + serverPort + ", Next State " + nextState); if (nextState == 1) { // Status request // Respond with server status (simplified) String statusJson = "{\"version\": {\"name\": \"My Server\", \"protocol\": " + protocolVersion + "}, \"players\": {\"max\": 10, \"online\": 0}, \"description\": {\"text\": \"A simple server\"}}"; sendString(out, statusJson); // Read ping packet and respond (simplified) packetId = in.readUnsignedByte(); if (packetId == 0x01) { long pingPayload = in.readLong(); sendLong(out, pingPayload); } } else if (nextState == 2) { // Login request // Handle login (simplified) String playerName = readString(in); System.out.println("Player " + playerName + " is trying to log in."); // **AI Integration Example:** Use AI to generate a welcome message PromptTemplate promptTemplate = new PromptTemplate("Generate a welcome message for player {playerName} joining the server."); promptTemplate.add("playerName", playerName); String aiWelcomeMessage = aiClient.generate(promptTemplate.create()).getGeneration().getText(); System.out.println("AI Welcome Message: " + aiWelcomeMessage); // Send login success (simplified) sendLoginSuccess(out, playerName); // Send a chat message (simplified) - including the AI message sendChatMessage(out, "Server: Welcome, " + playerName + "! " + aiWelcomeMessage); // Start game logic (simplified) - send join game packet, etc. sendJoinGame(out); } } // Keep the connection alive and handle further packets (simplified) while (clientSocket.isConnected()) { try { packetId = in.readUnsignedByte(); System.out.println("Received packet ID: " + packetId); // Example: Handle chat message (0x03) if (packetId == 0x03) { String chatMessage = readString(in); System.out.println("Received chat message: " + chatMessage); // **AI Integration Example:** Use AI to respond to the chat message PromptTemplate promptTemplate = new PromptTemplate("Respond to the following chat message: {chatMessage}"); promptTemplate.add("chatMessage", chatMessage); String aiResponse = aiClient.generate(promptTemplate.create()).getGeneration().getText(); System.out.println("AI Response: " + aiResponse); sendChatMessage(out, "Server (AI): " + aiResponse); } // Add more packet handling logic here... } catch (IOException e) { // Client disconnected System.out.println("Client disconnected: " + clientSocket.getInetAddress()); break; } } } catch (IOException e) { System.err.println("Client handler exception: " + e.getMessage()); e.printStackTrace(); } finally { try { clientSocket.close(); } catch (IOException e) { System.err.println("Error closing socket: " + e.getMessage()); } } } // Helper methods for reading and writing data (VarInt, String, etc.) - See below private int readVarInt(DataInputStream in) throws IOException { int numRead = 0; int result = 0; byte read; do { read = in.readByte(); int value = (read & 0x7f); result |= (value << (7 * numRead)); numRead++; if (numRead > 5) { throw new RuntimeException("VarInt is too big"); } } while ((read & 0x80) != 0); return result; } private String readString(DataInputStream in) throws IOException { int length = readVarInt(in); byte[] bytes = new byte[length]; in.readFully(bytes); return new String(bytes); } private void sendString(DataOutputStream out, String s) throws IOException { byte[] bytes = s.getBytes("UTF-8"); writeVarInt(out, bytes.length); out.write(bytes); } private void sendLong(DataOutputStream out, long l) throws IOException { out.writeByte(0x01); // Packet ID out.writeLong(l); out.flush(); } private void writeVarInt(DataOutputStream out, int value) throws IOException { while (true) { if ((value & ~0x7F) == 0) { out.writeByte(value); return; } else { out.writeByte((value & 0x7F) | 0x80); value >>>= 7; } } } private void sendChatMessage(DataOutputStream out, String message) throws IOException { out.writeByte(0x0F); // Chat Message packet ID sendString(out, "{\"text\":\"" + message + "\"}"); // JSON formatted chat message out.writeByte(0x00); // Position (0: chat box, 1: system message, 2: game info) out.writeByte(0x00); // Sender UUID (not used in this example) out.flush(); } private void sendLoginSuccess(DataOutputStream out, String playerName) throws IOException { out.writeByte(0x02); // Login Success packet ID sendString(out, "00000000-0000-0000-0000-000000000000"); // UUID (dummy) sendString(out, playerName); writeVarInt(out, 0); // Number of properties (none in this example) out.flush(); } private void sendJoinGame(DataOutputStream out) throws IOException { out.writeByte(0x26); // Join Game packet ID out.writeInt(0); // Entity ID out.writeByte(0); // Gamemode (Survival) out.writeByte(0); // Dimension (Overworld) out.writeByte(1); // Hashed seed out.writeByte(0); // Max Players sendString(out, "minecraft:overworld"); // Level Type writeVarInt(out, 32); // View Distance writeVarInt(out, 32); // Simulation Distance out.writeByte(0); // Reduced Debug Info out.writeByte(0); // Enable respawn screen out.writeByte(0); // Is hardcore out.writeByte(0); // Is flat out.flush(); } } } ``` **Explanation and Key Points:** 1. **Dependencies:** Make sure you have the necessary Spring Boot, Spring AI, and potentially other dependencies (like Netty for more robust networking) in your `pom.xml` or `build.gradle`. The example shows the Spring AI OpenAI starter. You'll need an OpenAI API key configured in your `application.properties` or `application.yml` file. 2. **`MinecraftServerApplication`:** A standard Spring Boot application entry point. 3. **`MinecraftServer`:** * `@Component`: Makes this a Spring-managed bean. * `@Autowired AiClient`: Injects the Spring AI client. This is how you access the AI functionality. * `@PostConstruct`: Ensures that `startServer()` is called after the Spring context is initialized. * `ServerSocket`: Listens for incoming connections on port 25565 (the default Minecraft port). * `ExecutorService`: A thread pool to handle multiple client connections concurrently. * `ClientHandler`: A `Runnable` that handles the communication with a single client. 4. **`ClientHandler`:** * `Socket`: Represents the connection to a Minecraft client. * `DataInputStream` and `DataOutputStream`: Used for reading and writing data to the client socket. Minecraft uses a binary protocol. * **Handshake (Simplified):** The code attempts to handle the initial handshake packet (ID 0x00). This is *highly* simplified. A real server needs to handle the handshake correctly to determine the client's protocol version and intended state (status or login). * **Status Request (Simplified):** If the client requests the server status (next state = 1), the server sends a basic JSON response with server information. * **Login Request (Simplified):** If the client requests to log in (next state = 2), the server reads the player's name. * **AI Integration (Welcome Message):** This is where Spring AI comes in. A `PromptTemplate` is used to create a prompt for the AI: "Generate a welcome message for player {playerName} joining the server." The `aiClient.generate()` method sends the prompt to the AI provider (e.g., OpenAI) and gets a response. The AI-generated message is then included in the chat message sent to the player. * **Chat Message Handling (Simplified):** The code attempts to handle chat messages (packet ID 0x03). * **AI Integration (Chat Response):** Another example of AI integration. The AI is used to respond to the player's chat message. * **Packet Handling:** The `while (clientSocket.isConnected())` loop is where you would add logic to handle other Minecraft packets. You need to read the packet ID and then parse the packet data according to the Minecraft protocol specification. * **Helper Methods:** The `readVarInt`, `readString`, `sendString`, `sendLong`, `writeVarInt`, `sendChatMessage`, `sendLoginSuccess`, and `sendJoinGame` methods are helper functions for reading and writing data in the format expected by the Minecraft protocol. `VarInt` is a variable-length integer encoding. 5. **AI Configuration:** You'll need to configure your Spring AI client in your `application.properties` or `application.yml` file. For example, if you're using OpenAI: ```properties spring.ai.openai.api-key=YOUR_OPENAI_API_KEY ``` **To Run This Example (Conceptual):** 1. **Create a Spring Boot project:** Use Spring Initializr (start.spring.io) to create a new Spring Boot project with the Web, Spring AI (OpenAI or another provider), and potentially other dependencies. 2. **Add the code:** Copy the code above into your project. 3. **Configure Spring AI:** Add your OpenAI API key (or the API key for your chosen AI provider) to your `application.properties` or `application.yml` file. 4. **Run the application:** Run the Spring Boot application. 5. **Connect with a Minecraft client:** Try connecting to `localhost:25565` with a Minecraft client. **Important:** This example is *very* basic and likely won't work perfectly with a standard Minecraft client without significant modifications. You'll probably need to use a custom client or a modified version of the game to test it effectively. **Next Steps (To Make This More Functional):** * **Implement the Full Minecraft Protocol:** This is the biggest task. You need to understand and implement the correct packet handling for all the packets you want to support. Refer to the Minecraft protocol documentation (e.g., on the Minecraft Wiki). * **World Management:** Create a system for loading, saving, and managing the game world. * **Player Management:** Track player data (inventory, position, health, etc.). * **Game Logic:** Implement the core game mechanics (e.g., block breaking, placing, entity movement, combat). * **Error Handling:** Add robust error handling to catch exceptions and prevent the server from crashing. * **Networking:** Consider using a more robust networking library like Netty for better performance and scalability. * **Security:** Implement security measures to prevent cheating and unauthorized access. * **Configuration:** Use Spring Boot's configuration features to make the server configurable (e.g., port number, world name, AI settings). **Important Notes on AI Integration:** * **Cost:** Using AI services like OpenAI can incur costs based on usage. Be mindful of your API usage and set limits if necessary. * **Latency:** AI requests can introduce latency. Consider using asynchronous processing or caching to minimize the impact on the game's responsiveness. * **Creativity vs. Control:** AI can generate creative content, but you may need to fine-tune the prompts and responses to ensure they fit the game's context and rules. * **Ethical Considerations:** Be aware of the ethical implications of using AI in your game, such as potential biases in the AI's responses. This example provides a starting point for building a Minecraft server with Spring AI. It's a complex project, but with careful planning and implementation, you can create a unique and engaging gaming experience. Remember to consult the Minecraft protocol documentation and the Spring AI documentation for more detailed information.

mcp-jenkins

Integrasi Model Context Protocol (MCP) Jenkins adalah implementasi sumber terbuka yang menjembatani Jenkins dengan model bahasa AI mengikuti spesifikasi MCP dari Anthropic. Proyek ini memungkinkan interaksi AI yang aman dan kontekstual dengan alat Jenkins sambil menjaga privasi dan keamanan data.

TWSE MCP Server

台灣證交所MCPServer

MMA MCP Server

Enables users to search and query information about military service alternative companies in South Korea through the Military Manpower Administration (MMA) API. Supports filtering by service type, industry, company size, location, and recruitment status.

Agent MCP BrightData

An intelligent agent using the Model Context Protocol to iteratively explore and analyze websites in a structured way, with built-in duplicate protection and conversational interface.

MCP Server on Cloudflare Workers & Azure Functions

A deployable MCP server for Cloudflare Workers or Azure Functions that provides example tools (time, echo, math), prompt templates for code assistance, and configuration resources. Enables AI assistants to interact with edge-deployed services through the Model Context Protocol.

Tiger MCP

Enables trading and market analysis through Tiger Brokers API integration. Provides real-time market data, portfolio management, order execution, and technical analysis tools with a comprehensive web dashboard for monitoring.

Minecraft MCP Server

A client library that connects AI agents to Minecraft servers, providing full game control with 30 verified skills for common tasks including movement, combat, crafting, and building.

UK Bus Departures MCP Server

Enables users to get real-time UK bus departure information and validate bus stop ATCO codes by scraping bustimes.org. Provides structured data including service numbers, destinations, scheduled and expected departure times for any UK bus stop.

MCP Perplexity Server

Provides AI-powered search, research, and reasoning capabilities through integration with Perplexity.ai, offering three specialized tools: general conversational AI, deep research with citations, and advanced reasoning.

Remote MCP Server on Cloudflare

A deployable Model Context Protocol server on Cloudflare Workers that enables AI models to access custom tools without authentication requirements.

MCP Weather Server

Enables users to retrieve current weather alerts for US states and detailed weather forecasts by geographic coordinates using the US National Weather Service API. Built with Node.js and TypeScript following Model Context Protocol standards for seamless LLM integration.

MCP2ANP Bridge Server

Enables MCP clients like Claude Desktop to interact with ANP (Agent Network Protocol) agents through three core tools: authentication setup, document fetching, and OpenRPC method invocation. Converts ANP's crawler-style interaction paradigm into MCP-compatible tools for seamless agent communication.

mcp_server

Okay, I understand. You're looking for a weather microservice (MCP likely refers to Microservice Communication Protocol) that can be accessed by a client IDE like Cursor. Here's a breakdown of how you could approach building such a system, along with considerations for Indonesian users: **1. Core Functionality: The Weather Microservice** * **Technology Stack:** * **Language:** Python (with Flask or FastAPI), Node.js (with Express), Go, or Java (with Spring Boot) are all good choices. Python is often favored for its ease of use and rich ecosystem of libraries for data handling. * **Framework:** Flask or FastAPI (Python), Express (Node.js), Spring Boot (Java) - These frameworks simplify building web APIs. * **Weather API:** You'll need to integrate with a third-party weather API. Popular options include: * **OpenWeatherMap:** Free and paid tiers. Good coverage, including Indonesia. * **AccuWeather:** Commercial API, generally reliable. * **WeatherAPI.com:** Another commercial option. * **Visual Crossing Weather:** Offers historical and forecast data. * **Data Storage (Optional):** If you want to cache weather data or store historical information, consider a database like PostgreSQL, MySQL, or MongoDB. Caching can significantly improve response times and reduce API usage costs. * **API Endpoints:** * `/weather/city/{city_name}`: Returns the current weather for a given city. Example: `/weather/city/Jakarta` * `/weather/coordinates/{latitude}/{longitude}`: Returns the current weather for a given latitude and longitude. Example: `/weather/coordinates/-6.2088/106.8456` (Jakarta coordinates) * `/forecast/city/{city_name}`: Returns a weather forecast for a given city. * `/forecast/coordinates/{latitude}/{longitude}`: Returns a weather forecast for given coordinates. * **Data Format:** JSON (JavaScript Object Notation) is the standard for API responses. * **Example (Python with Flask):** ```python from flask import Flask, jsonify import requests import os app = Flask(__name__) # Replace with your actual API key from OpenWeatherMap or another provider API_KEY = os.environ.get("WEATHER_API_KEY") or "YOUR_API_KEY" BASE_URL = "https://api.openweathermap.org/data/2.5/weather" # Example: OpenWeatherMap @app.route('/weather/city/<city_name>') def get_weather_by_city(city_name): try: url = f"{BASE_URL}?q={city_name}&appid={API_KEY}&units=metric" # Use metric for Celsius response = requests.get(url) response.raise_for_status() # Raise HTTPError for bad responses (4xx or 5xx) data = response.json() return jsonify(data) except requests.exceptions.RequestException as e: return jsonify({'error': str(e)}), 500 except Exception as e: return jsonify({'error': str(e)}), 500 @app.route('/weather/coordinates/<latitude>/<longitude>') def get_weather_by_coordinates(latitude, longitude): try: url = f"{BASE_URL}?lat={latitude}&lon={longitude}&appid={API_KEY}&units=metric" response = requests.get(url) response.raise_for_status() data = response.json() return jsonify(data) except requests.exceptions.RequestException as e: return jsonify({'error': str(e)}), 500 except Exception as e: return jsonify({'error': str(e)}), 500 if __name__ == '__main__': app.run(debug=True) ``` **Explanation:** * **Flask:** Sets up a simple web server. * **`API_KEY`:** Crucially, store your API key securely (environment variable is best). *Never* hardcode it directly into your code that you commit to a repository. * **`BASE_URL`:** The base URL for the weather API you're using. * **`get_weather_by_city` and `get_weather_by_coordinates`:** These are the API endpoints. They take the city name or coordinates as input, make a request to the weather API, and return the JSON response. * **Error Handling:** Includes basic error handling to catch network issues and API errors. * **`units=metric`:** Important for Indonesian users (and most of the world) to get temperatures in Celsius. **2. Client IDE Integration (Cursor Example)** * **Cursor Custom Command/Extension:** Cursor allows you to create custom commands or extensions. You'll need to write code (likely in JavaScript/TypeScript) that: 1. Takes user input (e.g., city name, coordinates). 2. Makes an HTTP request to your weather microservice's API endpoint. 3. Parses the JSON response from the microservice. 4. Displays the weather information in a user-friendly way within the Cursor IDE. * **Example (Conceptual Cursor Command):** ```javascript // (Conceptual - this is not complete, runnable Cursor code) async function getWeather(city) { const apiUrl = `http://localhost:5000/weather/city/${city}`; // Replace with your microservice URL try { const response = await fetch(apiUrl); const data = await response.json(); if (response.ok) { // Format and display the weather data in Cursor const temperature = data.main.temp; const description = data.weather[0].description; console.log(`Weather in ${city}: ${temperature}°C, ${description}`); // Or use Cursor's UI API to display it better } else { console.error(`Error: ${data.error}`); } } catch (error) { console.error(`Network error: ${error}`); } } // Example usage (triggered by a Cursor command) getWeather("Jakarta"); ``` **Key Considerations for Cursor Integration:** * **Cursor API:** You'll need to consult the Cursor documentation to understand how to create custom commands, access the editor, and display information. * **Asynchronous Operations:** Fetching data from the API is an asynchronous operation. Use `async/await` to handle it properly. * **Error Handling:** Robust error handling is essential. * **User Interface:** Think about how to present the weather information clearly and concisely within the IDE. **3. Indonesian Considerations (Localization)** * **City Names:** Handle Indonesian city names correctly (e.g., "Jakarta" vs. "DKI Jakarta"). Consider using a city name database or a geocoding API to map variations to the correct location. * **Language:** If you want to provide weather information in Indonesian, you'll need to: * Use a weather API that supports Indonesian language output (some do). * Translate the weather descriptions yourself (e.g., "clear sky" to "langit cerah"). This is more complex but gives you full control. * **Units:** Celsius is the standard in Indonesia, so ensure your API requests use `units=metric`. * **Time Zones:** Be mindful of time zones. Jakarta is in GMT+7. Display times in the user's local time zone. **4. Deployment** * **Microservice:** Deploy your weather microservice to a cloud platform like: * **Heroku:** Easy to deploy Python, Node.js, and other applications. * **AWS (Amazon Web Services):** More complex but very powerful. Use services like EC2, Lambda, and API Gateway. * **Google Cloud Platform (GCP):** Similar to AWS. Use services like Cloud Run, Cloud Functions, and API Gateway. * **Azure:** Microsoft's cloud platform. * **Cursor Extension:** The deployment of the Cursor extension will depend on how Cursor allows extensions to be distributed (e.g., a marketplace, manual installation). **5. Scalability and Reliability** * **Caching:** Implement caching to reduce API calls and improve response times. * **Monitoring:** Monitor your microservice's performance and error rates. * **Load Balancing:** If you expect a lot of traffic, use a load balancer to distribute requests across multiple instances of your microservice. * **Rate Limiting:** Implement rate limiting to prevent abuse of your API. **Example Indonesian Weather Response (Hypothetical):** ```json { "city": "Jakarta", "temperature": 30, "description": "Cerah berawan", // Partly cloudy "humidity": 70, "wind_speed": 5, "time": "2023-10-27 14:30 WIB" } ``` **In Indonesian:** Implementasi server MCP cuaca yang dapat dipanggil oleh IDE klien seperti Cursor. **Explanation of the Indonesian Translation:** * **Implementasi:** Implementation * **server MCP cuaca:** weather MCP server * **yang dapat dipanggil:** that can be called * **oleh IDE klien:** by a client IDE * **seperti Cursor:** like Cursor **Key Takeaways:** * Start with a simple weather microservice using a framework like Flask or FastAPI. * Integrate with a reliable weather API. * Focus on getting the core functionality working first. * Then, create a Cursor command/extension to access the microservice. * Consider Indonesian localization (city names, language, units). * Deploy your microservice to a cloud platform. * Think about scalability and reliability as your application grows. This is a comprehensive outline. You'll need to break it down into smaller tasks and implement each part step by step. Good luck!

System Information MCP Server

Provides comprehensive system diagnostics and hardware analysis through 10 specialized tools for troubleshooting and environment monitoring. Offers targeted information gathering for CPU, memory, network, storage, processes, and security analysis across Windows, macOS, and Linux platforms.