Discover Awesome MCP Servers

PostgreSQL MCP Server

Enables LLMs to interact deeply with PostgreSQL databases—query data, manage schema, analyze performance, and administer the database.

hive-exp

An MCP server enabling AI agents to record, query, and share structured problem-solving experiences with human review and confidence decay.

wheelfor-mcp

Create, spin, and manage shareable decision wheels on wheelfor.com. Supports creating wheels from any list of options, spinning for a random result, and getting a permanent shareable URL — no account required.

rce-cho-mcp

Enables querying the Dutch RCE Cultural Heritage Objects linked data endpoint via SPARQL, with ontology guidance and query validation for safe, accurate results.

FastMCP Demo Server

A production-ready MCP server that provides hackathon resources and reusable starter prompts. Built with FastMCP framework and includes comprehensive deployment options for development and production environments.

mcp-units

MCP server for converting cooking measurements (volume, weight, temperature) between common units like ml, cup, g, oz, and Celsius/Fahrenheit.

MCP Tool Server

A Model Context Protocol server that advertises tools with JSON schemas and executes tool calls safely, enabling AI agents to perform actions on real systems.

MyWeight MCP Server

A server that connects to the Health Planet API to fetch and provide weight measurement data through any MCP-compatible client, allowing for retrieval and analysis of personal weight records.

Universal Adapter

Enables autonomous task execution by dynamically searching APIs, generating Python tools, and running them on-demand, with built-in web search, scraping, and file operations.

@theyahia/voximplant-mcp

MCP server for Voximplant API enabling calls, SMS, recordings, scenarios, and rules management with 11 tools and 2 skills.

Finizi B4B MCP Server

Enables AI assistants to interact with the Finizi B4B platform through 15 comprehensive tools for managing business entities, invoices, vendors, and products. Features secure JWT authentication, automatic retries, and comprehensive business data operations through natural language commands.

terminal-toolkit-mcp

Enables LLM clients to execute shell commands safely through the MCP protocol, with features like session management, safe mode, and process control.

Accounting MCP Server

Enables personal financial management through AI assistants by providing tools to add transactions, check balances, list transaction history, and generate monthly summaries. Supports natural language interaction for tracking income and expenses with categorization.

Build

Okay, I can help you understand how to use the TypeScript SDK to create different MCP (Model Configuration Protocol) servers. However, I need a little more information to give you the *most* helpful and specific answer. Please tell me: 1. **What MCP server are you trying to create?** Are you trying to create a custom MCP server for a specific game, or are you trying to create a generic MCP server? 2. **What TypeScript SDK are you referring to?** There are many TypeScript SDKs that could be used to create an MCP server. Please provide the name of the SDK or a link to the documentation. 3. **What functionality do you need?** What specific features do you need your MCP server to support? For example, do you need to support authentication, authorization, or data validation? In the meantime, here's a general outline of how you might approach creating an MCP server using TypeScript, assuming you're building a custom server and not using a pre-built SDK (which would have its own specific instructions): **General Approach (Custom Implementation):** 1. **Project Setup:** * Initialize a new TypeScript project: ```bash mkdir my-mcp-server cd my-mcp-server npm init -y npm install typescript --save-dev npm install express body-parser cors --save # Common dependencies for a web server npm install --save-dev @types/node @types/express @types/body-parser @types/cors # Type definitions npx tsc --init # Initialize tsconfig.json ``` * Configure `tsconfig.json`: Adjust settings like `target`, `module`, `outDir`, `rootDir`, `esModuleInterop`, and `strict` to suit your project's needs. A basic example: ```json { "compilerOptions": { "target": "es6", "module": "commonjs", "outDir": "./dist", "rootDir": "./src", "strict": true, "esModuleInterop": true, "skipLibCheck": true, "forceConsistentCasingInFileNames": true }, "include": ["src/**/*"], "exclude": ["node_modules"] } ``` 2. **Define Data Structures (Interfaces/Types):** * Create TypeScript interfaces or types to represent the data structures used in the MCP protocol. This will depend entirely on the specific MCP protocol you're implementing. For example: ```typescript // src/types/mcp.ts export interface ModelConfiguration { modelId: string; version: number; parameters: { [key: string]: any }; } export interface MCPRequest { requestId: string; action: "get" | "set" | "delete"; modelId?: string; configuration?: ModelConfiguration; } export interface MCPResponse { requestId: string; status: "success" | "error"; data?: ModelConfiguration | null; error?: string; } ``` 3. **Implement the Server (using Express.js):** * Create an Express.js server to handle MCP requests. ```typescript // src/index.ts import express, { Request, Response } from 'express'; import bodyParser from 'body-parser'; import cors from 'cors'; import { MCPRequest, MCPResponse, ModelConfiguration } from './types/mcp'; const app = express(); const port = 3000; app.use(cors()); app.use(bodyParser.json()); // In-memory storage (replace with a database in a real application) const modelConfigurations: { [modelId: string]: ModelConfiguration } = {}; app.post('/mcp', (req: Request, res: Response) => { const mcpRequest: MCPRequest = req.body; console.log("Received MCP Request:", mcpRequest); switch (mcpRequest.action) { case "get": if (!mcpRequest.modelId) { sendErrorResponse(res, mcpRequest.requestId, "Model ID is required for 'get' action."); return; } const config = modelConfigurations[mcpRequest.modelId]; if (config) { sendSuccessResponse(res, mcpRequest.requestId, config); } else { sendSuccessResponse(res, mcpRequest.requestId, null); // Model not found } break; case "set": if (!mcpRequest.configuration) { sendErrorResponse(res, mcpRequest.requestId, "Configuration is required for 'set' action."); return; } if (!mcpRequest.configuration.modelId) { sendErrorResponse(res, mcpRequest.requestId, "Model ID is required in the configuration for 'set' action."); return; } modelConfigurations[mcpRequest.configuration.modelId] = mcpRequest.configuration; sendSuccessResponse(res, mcpRequest.requestId, mcpRequest.configuration); break; case "delete": if (!mcpRequest.modelId) { sendErrorResponse(res, mcpRequest.requestId, "Model ID is required for 'delete' action."); return; } delete modelConfigurations[mcpRequest.modelId]; sendSuccessResponse(res, mcpRequest.requestId, null); break; default: sendErrorResponse(res, mcpRequest.requestId, "Invalid action."); } }); function sendSuccessResponse(res: Response, requestId: string, data: ModelConfiguration | null) { const response: MCPResponse = { requestId: requestId, status: "success", data: data, }; res.json(response); } function sendErrorResponse(res: Response, requestId: string, errorMessage: string) { const response: MCPResponse = { requestId: requestId, status: "error", error: errorMessage, }; res.status(400).json(response); } app.listen(port, () => { console.log(`MCP Server listening at http://localhost:${port}`); }); ``` 4. **Implement MCP Logic:** * Implement the core logic for handling MCP requests. This will involve: * Parsing the request. * Validating the request. * Retrieving, updating, or deleting model configurations. * Constructing the response. 5. **Data Storage:** * Choose a data storage mechanism to store model configurations. This could be: * In-memory storage (for simple prototypes). * A file-based database (e.g., SQLite). * A relational database (e.g., PostgreSQL, MySQL). * A NoSQL database (e.g., MongoDB, Redis). 6. **Error Handling:** * Implement robust error handling to gracefully handle invalid requests, data validation errors, and other potential issues. 7. **Authentication and Authorization (if needed):** * If your MCP server needs to be secure, implement authentication and authorization mechanisms to control access to model configurations. 8. **Build and Run:** * Compile the TypeScript code: `npm run build` (or `tsc` if you haven't configured a build script). * Run the server: `node dist/index.js` **Example Request (using `curl`):** ```bash curl -X POST -H "Content-Type: application/json" -d '{ "requestId": "123", "action": "set", "configuration": { "modelId": "myModel", "version": 1, "parameters": { "param1": "value1", "param2": 123 } } }' http://localhost:3000/mcp ``` **Important Considerations:** * **Security:** If your MCP server will be exposed to a network, security is paramount. Use HTTPS, implement authentication and authorization, and carefully validate all input. * **Scalability:** If you anticipate a high volume of requests, consider using a scalable architecture, such as a load balancer and multiple server instances. * **Monitoring:** Implement monitoring to track the health and performance of your MCP server. * **Testing:** Write unit tests and integration tests to ensure that your MCP server is working correctly. **Example `package.json` (with build script):** ```json { "name": "my-mcp-server", "version": "1.0.0", "description": "", "main": "index.js", "scripts": { "build": "tsc", "start": "node dist/index.js", "dev": "ts-node-dev --respawn src/index.ts" }, "keywords": [], "author": "", "license": "ISC", "dependencies": { "body-parser": "^1.20.2", "cors": "^2.8.5", "express": "^4.18.2" }, "devDependencies": { "@types/body-parser": "^1.19.5", "@types/cors": "^2.8.17", "@types/express": "^4.17.21", "@types/node": "^20.10.5", "ts-node-dev": "^2.0.0", "typescript": "^5.3.3" } } ``` **To run this example:** 1. Save the code into the appropriate files (e.g., `src/index.ts`, `src/types/mcp.ts`). 2. Run `npm install` to install dependencies. 3. Run `npm run build` to compile the TypeScript code. 4. Run `npm start` to start the server. **Next Steps:** Provide more details about the specific MCP server you're trying to create, the SDK you're using, and the functionality you need, and I can give you more tailored guidance.

au-weather-mcp

Provides access to Australian weather data from the Bureau of Meteorology, enabling location search, forecasts, and current observations.

Prompt Bookmarks

Enables users to organize, search, and manage a shared library of prompts across AI tools via the Model Context Protocol. It supports hierarchical folder organization, tagging, and template variable substitution for dynamic prompt generation.

Android Puppeteer

Enables AI agents to interact with Android devices through visual UI element detection and automated interactions. Provides comprehensive Android automation capabilities including touch gestures, text input, screenshots, and video recording via uiautomator2.

MCP Vaultwarden Server

Enables AI agents and automation scripts to securely interact with self-hosted Vaultwarden instances through the Bitwarden CLI, automatically managing vault sessions and providing tools to read, create, update, and delete secrets programmatically.

Resend MCP Server

Enables sending emails via the Resend API from Claude, with tools for sending, checking delivery status, listing recent emails, and managing domains.

GraphMemory-IDE

An AI-assisted, long-term memory system for IDEs, powered by Kuzu graph database. GraphMemory-IDE is an MCP server that provides semantic vector search, graph-based knowledge storage, and real-time analytics.

Mirdan

Automatically enhances developer prompts with quality requirements, codebase context, and architectural patterns, then orchestrates other MCP servers to ensure AI coding assistants produce high-quality, structured code that follows best practices and security standards.

Arkana

An MCP server that provides 294 malware analysis tools behind an AI-driven interface, enabling natural language investigation of binaries.

findata-mcp

A Financial Data Quality and AI Inference Evaluation MCP server that provides tools for auditing, bias detection, model evaluation, outlier scoring, A/B testing, and KPI reporting.

x64dbg MCP server

Um servidor MCP para o depurador x64dbg.

Internship Scout & Quality of Life MCP Server

Integrates Eurostat quality-of-life metrics and real-time job searching to help users find international internships in high-ranking European cities. It enables ranking cities based on personalized criteria like safety or transport and retrieves structured internship listings via the Tavily API.

EditX

An MCP server for taking screenshots and editing images with annotations, shapes, and effects.

mcp-sphinx-docs

Converts Sphinx documentation (RST) to Markdown optimized for LLMs, enabling easy consumption of technical documentation by language models.

mcp-mysql-apifox

MCP server for executing MySQL SQL, managing Apifox API documentation, and parsing/executing curl commands.

mark-coach-mcp

Local MCP server that turns Mark Builds Brands' YouTube knowledge into an AI coaching assistant for ecommerce and Facebook Ads.

mcp-coinbase

Browser-automated MCP server for Coinbase crypto exchange, enabling live prices, portfolio management, transaction history, and trading.