Provides a community platform for users to connect with other contributors, with links to join the server for support and collaboration.
Built on Node.js runtime, enabling server-side JavaScript execution for AI model interactions.
Uses pnpm for package management with specific commands for installation and running the server in different modes.
Enables one-click deployment of the MCP server to Railway's platform, providing a frictionless hosting solution.
Uses TypeScript for full type safety with input/output schemas, allowing developers to create type-safe tools and prompts.
Integrates Zod for schema validation, allowing developers to define strict input/output schemas for tools with automatic validation.
D0UGWITHSEISMIC/WITHSEISMIC-MCP
A production-ready MCP server template for hosting your own AI tools and prompts. Deploy remotely or run locally - built for developers who want to expose their tools to AI models without the infrastructure headaches.
://WHO_IS_THIS_FOR?
This template is perfect for:
- AI Tool Developers: Build and host your own tools that AI models can interact with
- Teams & Organizations: Set up a shared MCP server for your AI applications
- Individual Developers: Quick-start your MCP development with a production-ready setup
- API Providers: Expose your services to AI models through a standardized interface
Whether you want to:
- 🌐 Host a remote MCP server that multiple clients can connect to
- 🔧 Run locally via stdio for development and testing
- 🚀 Deploy a production-ready MCP implementation
- 🛠️ Build tools without worrying about infrastructure
This template provides everything you need to get started.
://OVERVIEW
The MCP server provides two ways to expose your tools to AI models:
- Remote Server Mode (SSE): Deploy as a remote server that multiple clients can connect to
- Perfect for production deployments
(
pnpm start:sse
) - Supports multiple simultaneous connections
- Easy deployment to platforms like Railway
- Secure and scalable
- Perfect for production deployments
(
- Local Mode (stdio): Run locally for development and testing
(
pnpm start
)- Great for local development
- Direct stdio communication
- Fast iteration and debugging
Key Features:
- Tools: Executable functions that models can call
- Prompts: Template-based message generators
- Auto-Discovery: Automatic registration of your components
- Type Safety: Full TypeScript support throughout
://WHY_USE_THIS_MCP_SERVER_TEMPLATE?
While the Model Context Protocol (MCP) is in its early stages, one thing is clear: rapid adoption requires frictionless development. This implementation is built with a singular focus: letting developers focus on building great tools, not infrastructure.
INSTANT_DEPLOYMENT
ZERO_FRICTION_DEVELOPMENT
- No Boilerplate: Define your tool, import it, and you're done. We handle the rest.
- Auto-Registration: Tools and prompts are automatically discovered and registered.
- Type Safety: Full TypeScript support with zero configuration.
BATTLE_TESTED_ARCHITECTURE
- Production Ready: Built for reliability and performance.
- Scalable Design: From simple tools to complex AI interactions.
- Error Resilient: Robust error handling and debugging built-in.
DEVELOPER_EXPERIENCE_FIRST
We handle:
- ⚡ Connection management
- 🔄 Tool registration
- 🛡️ Input validation
- 📦 State management
- 🚨 Error handling
- 📊 Logging and metrics
You focus on:
- 🎯 Building amazing tools
- 🧠 Creating powerful prompts
- 🚀 Shipping features
://GETTING_STARTED
INSTALLATION
RUNNING_THE_SERVER
Two modes are available:
- Standard mode (stdio):
- SSE (Server-Sent Events) mode:
When running in SSE mode, connect to: http://localhost:3001/sse
://CORE_CONCEPTS
TOOLS
Tools are executable functions that models can invoke. Each tool:
- Has defined input/output schemas using Zod
- Is automatically registered with the registry
- Can perform any operation (calculation, file I/O, API calls, etc.)
Example tool:
PROMPTS
Prompts are message generators that help structure model interactions. Each prompt:
- Defines its argument schema
- Generates messages in a consistent format
- Is automatically registered with the registry
Example prompt:
://ADDING_NEW_COMPONENTS
Creating a New Tool
- Create a new file in
src/modules/tools/
- Define your input/output schemas using Zod
- Create and export your tool instance
- Add the export to
src/modules/tools/index.ts
The registry will automatically:
- Register your tool
- Make it available to models
- Handle validation and error handling
Creating a New Prompt
- Create a new file in
src/modules/prompts/
- Define your argument schema
- Create and export your prompt instance
- Add the export to
src/modules/prompts/index.ts
The registry will automatically:
- Register your prompt
- Make it available to models
- Handle message generation and errors
Architecture
Core Components
- Registry: Central manager for all tools and prompts
- Tool: Base class for executable functions
- Prompt: Base class for message generators
- Server: MCP protocol implementation
Auto-Registration
The system uses a singleton Registry pattern that:
- Automatically registers tools and prompts on import
- Provides type-safe access to components
- Handles all MCP protocol interactions
Error Handling
The system includes robust error handling:
- Type validation via Zod schemas
- Execution error wrapping
- Detailed error messages for debugging
Development
Type Safety
All components use TypeScript for full type safety:
- Input/output schemas are defined using Zod
- Type inference for tool arguments and results
- Comprehensive error types
Testing
Run tests using:
Best Practices
- Always define clear input/output schemas
- Use descriptive names and documentation
- Handle errors gracefully
- Follow the TypeScript guidelines in the codebase
://CONTRIBUTING
We welcome contributions! Please see our Contributing Guide for details on:
- Development workflow
- Code style guidelines
- Pull request process
- Issue reporting
Join our Discord community to connect with other contributors!
://SUPPORT
- 📫 Email: hello@withseismic.com
- 💬 Discord: Join our server
://LICENSE
This project is licensed under the MIT License - see the LICENSE file for details.
© 2025 Doug, at WithSeismic dot com.
This server cannot be installed
hybrid server
The server is able to function both locally and remotely, depending on the configuration or use case.
A TypeScript implementation of a Model Context Protocol server that provides a frictionless framework for developers to build and deploy AI tools and prompts, focusing on developer experience with zero boilerplate and automatic tool registration.
- ://WHO_IS_THIS_FOR?
- ://OVERVIEW
- ://WHY_USE_THIS_MCP_SERVER_TEMPLATE?
- ://GETTING_STARTED
- ://CORE_CONCEPTS
- ://ADDING_NEW_COMPONENTS
- Architecture
- Development
- ://CONTRIBUTING
- ://SUPPORT
- ://LICENSE
Related Resources
Related MCP Servers
- -securityFlicense-qualityA Model Context Protocol implementation for managing and serving AI prompts with a TypeScript-based architecture in a monorepo structure.Last updated -33,014,56411TypeScript
- AsecurityAlicenseAqualityA TypeScript-based Model Context Protocol toolkit that enables AI to interact with code files, manage translations, build projects, and search for files and code content.Last updated -33115TypeScriptMIT License
- -securityFlicense-qualityA TypeScript-based starter template for building Model Context Protocol servers that enables AI assistants to dynamically call tools, interpret prompts, and manage resources through modular architecture with support for multiple transport methods.Last updated -TypeScript
- -securityFlicense-qualityA foundation for developing custom Model Context Protocol servers in TypeScript that connects AI assistants with external APIs and data sources using a complete layered architecture pattern.Last updated -124TypeScript