Discover MCP Servers

Explore a curated collection of Model Context Protocol servers. Find the perfect tools to enhance your AI applications.

2 servers available

Resume MCP

v1.3.1

Resume MCP Server

A Model Context Protocol (MCP) server built in Go that allows AI agents to manage resume data and generate HTML previews. The project combines an MCP server with a REST API for preview functionality.

Features

Resume Management: Create, update, and delete resumes with structured data
Template System: Create and manage Go templates for resume rendering
HTML Preview: Generate HTML previews with custom styling
Flexible Data Model: Support for contacts, work experience, education, and custom feature maps
Copy Functionality: Duplicate existing resumes and templates with all related data
REST API: HTTP endpoints for preview generation and styling

Installation

Download Pre-built Binary

Download the latest release from: https://github.com/rxtech-lab/resume-mcp/releases For macOS users, download resume-mcp_macOS_arm64.pkg and run the installer.

Build from Source

# Clone the repository
git clone https://github.com/rxtech-lab/resume-mcp.git
cd resume-mcp

# Build the project
make build

# Run tests
make test

# Run the MCP server
make run

Usage

MCP Tools

The server provides comprehensive MCP tools for resume management:

Resume Management

create_resume - Create new resume with basic info (supports copying from existing)
update_basic_info - Update resume name, photo, and description
get_resume_by_name - Retrieve resume data by name
list_resumes - List all saved resumes
delete_resume - Delete resume by ID

Contact Information

add_contact_info - Add contact details (email, phone, etc.)

Experience Management

add_work_experience - Add work experience entries
add_education - Add education entries
add_other_experience - Add other experience categories

Feature Maps

add_feature_map - Add flexible JSON features to experiences
update_feature_map - Update existing feature maps
delete_feature_map - Delete feature maps

Template System

create_template - Create Go templates for resume rendering (supports copying data)
get_template - Retrieve template by ID
list_templates - List templates for a resume
update_template - Update existing templates
delete_template - Delete templates

Preview Generation

generate_preview - Generate HTML preview using template and resume data
update_preview_style - Update CSS styles for existing previews
get_resume_context - Get comprehensive resume data and schema guide for template creation

Copy Functionality

Both create_resume and create_template tools support copying from existing data:

# Copy all data from an existing resume when creating a new one
create_resume(name="New Resume", copy_from_resume_id="1")

# Copy data from one resume to another when creating a template
create_template(resume_id="2", copy_from_resume_id="1", name="My Template")

Template Examples

The server supports Go template syntax for resume rendering:

<div class="resume">
  <h1>{{.Name}}</h1>
  <p>{{.Description}}</p>
  
  {{if .Contacts}}
  <div class="contact">
    {{range .Contacts}}
    <p>{{.Key}}: {{.Value}}</p>
    {{end}}
  </div>
  {{end}}
  
  {{if .WorkExperiences}}
  <div class="experience">
    {{range .WorkExperiences}}
    <div>
      <h3>{{.JobTitle}} at {{.Company}}</h3>
      <p>{{.StartDate.Format "Jan 2006"}} - {{if .EndDate}}{{.EndDate.Format "Jan 2006"}}{{else}}Present{{end}}</p>
      {{range .FeatureMaps}}
      <p>{{.Key}}: {{.Value}}</p>
      {{end}}
    </div>
    {{end}}
  </div>
  {{end}}
</div>

Architecture

Core Components

MCP Server: Built using github.com/mark3labs/mcp-go
REST API: Fiber framework for HTTP endpoints
Database: GORM with SQLite for local storage
Template Engine: Go templates with Tailwind CSS support
Preview Generation: On-demand HTML generation

Data Model

Resume: Basic info (name, photo, description)
Contact: Key-value pairs for contact information
WorkExperience: Job history with dates and details
Education: Educational background
OtherExperience: Flexible categories for additional experiences
FeatureMap: Custom JSON data for any experience type
Template: Go templates for resume rendering

Workflow

AI agent creates resume using MCP tools
Agent adds contacts, experiences, and feature maps
Agent creates templates for rendering
Agent generates HTML previews with custom styling
User visits preview URL to view rendered resume

Development

Prerequisites

Go 1.21 or higher
Make

Commands

# Build the project
make build

# Run tests
make test

# Run the MCP server
make run

# Clean build artifacts
make clean

# Install locally (requires sudo)
make install-local

# Create package (macOS)
make package

Testing

The project includes comprehensive unit tests for all MCP tools:

# Run all tests
make test

# Run tests with verbose output
go test ./tools -v

# Run specific test
go test ./tools -run TestCreateResumeTool

API

Preview URLs

The server runs an HTTP API on port 8080 for preview generation:

GET /resume/preview/:sid - View generated HTML preview

Database

Type: SQLite
Location: resume.db (created automatically)
Migrations: Automatic on startup

Contributing

Fork the repository
Create a feature branch
Add tests for new functionality
Ensure all tests pass: make test
Build the project: make build
Submit a pull request

License

This project is licensed under the MIT License. See the LICENSE file for details.

Support

For issues and questions, please visit: https://github.com/rxtech-lab/resume-mcp/issues

resume

networking

RemoteLocal

LaunchPad

v2.2.2

Crypto Launchpad MCP Server

AI-powered crypto launchpad supporting Ethereum and Solana blockchains. Unlike traditional web-based launchpads, this uses AI as the interface for easy token creation and management.

Download

Visit cryptolaunch.app to download the latest version of the Crypto Launchpad MCP server for your platform.

Features

AI-First Interface: Natural language commands for blockchain operations
Multi-Chain Support: Ethereum and Solana blockchain integration
Smart Contract Templates: Pre-built and customizable contract templates
Uniswap Integration: Complete DEX functionality for liquidity management
Secure Signing: EIP-6963 wallet discovery with client-side transaction signing
Real-time Monitoring: Pool metrics and transaction tracking

Quick Start

Prerequisites

Go 1.24.5 or later
Modern web browser with wallet extension (MetaMask, Coinbase Wallet, etc.)

Installation

Clone the repository:

git clone <repository-url>
cd launchpad-mcp

Install dependencies:

make deps

Build the project:

make build

Run the server:

make run

Docker Deployment

For production deployments, you can use the pre-built Docker images from GitHub Container Registry:

Using Docker Run

# Pull and run the latest image
docker run -d \
  --name launchpad-mcp \
  -p 8080:8080 \
  -e POSTGRES_URL="your_postgres_url" \
  ghcr.io/rxtech-lab/launchpad-mcp:latest

Using Docker Compose

Copy the environment file:

cp .env.example .env

Edit .env with your configuration
Run with Docker Compose:

# Run with SQLite (default)
docker compose up -d

# Run with PostgreSQL
docker compose --profile postgres up -d

Building Locally

# Build multi-architecture image
docker buildx build \
  --platform linux/amd64,linux/arm64 \
  --build-arg VERSION=dev \
  --build-arg COMMIT_HASH=$(git rev-parse HEAD) \
  --build-arg BUILD_TIME=$(date -u '+%Y-%m-%d_%H:%M:%S') \
  -t launchpad-mcp .

Available Tags

latest - Latest stable release
v1.0.0 - Specific version tags
main-<sha> - Latest main branch build

MCP Tools

The server provides 14 MCP tools for comprehensive crypto launchpad operations:

Chain Management

select-chain - Select blockchain (ethereum/solana)
set-chain - Configure RPC and chain ID

Template Management

list-template - Search contract templates
create-template - Create new templates
update-template - Modify existing templates

Token Deployment

launch - Deploy contracts with signing interface

Uniswap Integration

set-uniswap-version - Configure Uniswap version
create-liquidity-pool - Create new pools
add-liquidity - Add liquidity to pools
remove-liquidity - Remove liquidity from pools
swap-tokens - Execute token swaps
get-pool-info - View pool metrics
get-swap-quote - Get swap estimates
monitor-pool - Real-time pool monitoring

Architecture

Dual Server Design

MCP Server: Handles AI tool requests via stdio
HTTP Server: Provides transaction signing interfaces on random port

Database

SQLite database stored at ~/launchpad.db
Automatic migrations and schema management
Session-based transaction tracking

Frontend

HTMX + Tailwind CSS for reactive interfaces
EIP-6963 wallet discovery for maximum compatibility
Client-side transaction signing for security

Usage Examples

Basic Workflow

Setup Chain:

AI: Please select Ethereum as the active blockchain
Tool: select-chain(chain_type="ethereum")

Configure Network:

AI: Set up Sepolia testnet
Tool: set-chain(chain_type="ethereum", rpc="https://sepolia.infura.io/v3/...", chain_id="11155111")

Deploy Token:

AI: Deploy a token called "MyToken" with symbol "MTK"
Tool: launch(template_id="1", token_name="MyToken", token_symbol="MTK", deployer_address="0x...")
Result: Signing URL generated for wallet connection

Create Liquidity Pool:

AI: Create a Uniswap pool with 1000 tokens and 1 ETH
Tool: create-liquidity-pool(token_address="0x...", initial_token_amount="1000", initial_eth_amount="1")
Result: Pool creation URL for user signing

Transaction Signing Flow

AI tool generates unique signing URL
User opens URL in browser
Frontend loads with transaction details
User connects wallet via EIP-6963
User reviews and signs transaction
Real-time status updates
Database updated with transaction hash

Development

Project Structure

├── cmd/main.go              # Application entry point
├── internal/
│   ├── api/                 # HTTP server for signing
│   ├── database/            # Database layer
│   ├── mcp/                 # MCP server
│   └── models/              # Data models
├── tools/                   # MCP tool implementations
├── templates/               # Frontend assets
└── docs/                    # Documentation

Adding New Tools

Create tool file in tools/ directory following the pattern:

func NewMyTool(db *database.Database) (mcp.Tool, server.ToolHandlerFunc) {
    tool := mcp.NewTool("my_tool", ...)
    handler := func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
        // Implementation
    }
    return tool, handler
}

myTool, myHandler := tools.NewMyTool(db)
srv.AddTool(myTool, myHandler)

Testing

Run all tests:

make test

Building

Build for production:

make build

Clean build artifacts:

make clean

Security

No Private Keys: System never handles private keys
Client-Side Signing: All transactions signed in user's browser
Session Expiry: 30-minute timeout for signing sessions
Input Validation: All parameters validated before processing
Template Validation: Smart contracts checked for security issues

Supported Networks

Ethereum

Mainnet (Chain ID: 1)
Sepolia (Chain ID: 11155111)
Goerli (Chain ID: 5)
Custom networks via RPC configuration

Solana

Mainnet Beta
Devnet
Testnet
Custom RPC endpoints

Limitations

Uniswap v3/v4 support is experimental (v2 fully supported)
Solana DEX integration not yet implemented
Real-time price feeds require external APIs
Advanced trading features (limit orders, etc.) not included

Contributing

Fork the repository
Create feature branch
Add comprehensive tests
Follow existing code patterns
Submit pull request

License

[License details here]

Support

For issues and questions:

GitHub Issues: [Repository issues page]
Documentation: docs/ directory
Example code: example/ directory

cryptoethereum

crypto

RemoteLocal

Loading servers...