Discover Awesome MCP Servers

TAKO MCP Server for Okta

Enables AI assistants to securely query and manage Okta resources for IAM and security administration. It supports dual-mode operation for standard tool interaction or autonomous agent workflows with sandboxed code execution.

random-number-server

An MCP server that generates random numbers by using national weather data as entropy seeds. It provides a unique way to generate random values through weather API integration within the Model Context Protocol.

Amazon Business Integrations MCP Server

Provides AI-enabled access to Amazon Business API documentation, sample code, and troubleshooting resources. Enables developers to search and retrieve API documentation, generate integration code, and get guided solutions for common errors during the API integration process.

PinePaper MCP Server

Enables AI assistants to create and animate graphics in PinePaper Studio using natural language, supporting text, shapes, behavior-driven animations, procedural backgrounds, and SVG export.

WuWa MCP Server

Enables querying detailed information about characters, echoes, and character profiles from the Wuthering Waves game, returning results in LLM-optimized Markdown format.

Anonymix MCP

Provides local anonymization of Czech legal documents by replacing sensitive entities with pseudonyms to ensure privacy during LLM interactions. It allows users to safely process documents like contracts and judgments by keeping original data offline and facilitating local deanonymization.

Google Search MCP Server

A Model Context Protocol server that provides web and image search capabilities through Google's Custom Search API, allowing AI assistants like Claude to access current information from the internet.

Vercel Functions MCP Server Template

A template for deploying MCP servers on Vercel with serverless functions. Includes example tools for rolling dice and fetching weather data to demonstrate basic tool implementation and API integration patterns.

Mnehmos Synch

Provides persistent context synchronization and memory management for AI agents across sessions and projects, including file indexing, bug tracking, spatial navigation, and agent-to-agent handoff coordination.

HaloPSA MCP Server

Enables AI assistants to interact with HaloPSA data through secure OAuth2 authentication. Supports SQL queries against the HaloPSA database, API endpoint exploration, and direct API calls for comprehensive PSA data analysis and management.

Cirvoy-Kiro MCP Integration

Enables seamless task synchronization between Kiro IDE and the Cirvoy project management platform. It provides tools to create, list, and update tasks directly within the IDE using the Model Context Protocol.

market-data-mcp

Real-time financial market data MCP server. Stocks, crypto, technicals, sentiment, FDA calendar. No API keys required.

stacksfinder-mcp

Tech stack recommendations for developers. Deterministic 6-dimension scoring across 30+ technologies. 4 free tools, Pro features with API key.

The Investor Har Store

An MCP server that lets AI agents autonomously buy physical hats using USDC on Base — no credit card, no checkout, no human required. Browse the catalog, get a real-time shipping quote, send crypto, and we ship the hat.

Bubble MCP

Enables AI assistants to interact with Bubble.io applications through the Model Context Protocol for data discovery, CRUD operations, and workflow execution. It provides a standardized interface for managing Bubble database records while respecting privacy rules and security configurations.

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.

XFetch Mcp

Busca turbinada/aprimorada. Permite recuperar conteúdo de qualquer página da web, incluindo aquelas protegidas pelo Cloudflare e outros sistemas de segurança.

Bocha Search MCP

Um motor de busca focado em IA que permite que aplicações de IA acessem conhecimento de alta qualidade de bilhões de páginas da web e fontes de conteúdo do ecossistema em vários domínios, incluindo clima, notícias, enciclopédia, informações médicas, passagens de trem e imagens.

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.

Fortnox Doc MCP

Provides comprehensive documentation for 377 Fortnox API endpoints and 81 resource categories directly from the official OpenAPI specification. It enables users to search, browse, and explore technical endpoint details and data schemas within AI assistants without requiring authentication.

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.

Agent MCP

A Multi-Agent Collaboration Protocol server that enables coordinated AI collaboration through task management, context sharing, and agent interaction visualization.

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.

fal-mcp

An MCP server that integrates fal.ai's image generation and editing capabilities into MCP-compatible clients. It enables text-to-image generation, style application via LoRAs, and image editing using natural language instructions.

Weather MCP

Provides weather query capabilities including current weather, daily/hourly forecasts, air quality data, and weather alerts through QWeather API integration with JWT-based authentication.

Zero Network MCP Server

Provides AI agents with access to Zero Network documentation, SDK integration guides, and utility tools for crypto-based payments. It enables developers to implement x402 paywalls and per-tool MCP pricing while offering real-time cost estimations and revenue calculations.