Discover MCP Servers

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

3 servers available

Invoice management mcp

v1.10.2

Invoice Management System

A comprehensive invoice management system built with Go and Next.js, featuring AI-powered search and Model Context Protocol (MCP) integration.

Features

📄 Invoice Management: Create, read, update, and delete invoices with detailed line items
🏢 Company & Receiver Management: Organize vendors and invoice recipients
🏷️ Categories & Tags: Flexible categorization and tagging system
📊 Analytics & Reporting: Built-in analytics and statistics dashboard
📤 File Upload: S3-compatible storage for invoice attachments
🔍 AI-Powered Search: Intelligent search capabilities using AI SDK
🤖 MCP Server: Model Context Protocol integration for AI assistants
💱 Currency Support: Multi-currency with exchange rate conversion
🔐 OAuth Authentication: Secure authentication with JWT tokens
📱 Responsive UI: Modern Next.js frontend with mobile support

Tech Stack

Backend

Go 1.25+: Main backend language
Fiber v2: Fast HTTP framework
GORM: ORM for database operations
Turso/SQLite: Database (supports both local SQLite and Turso)
AWS SDK v2: S3-compatible storage integration
MCP Go: Model Context Protocol server implementation
OpenAPI 3.0: API specification and code generation

Frontend

Next.js 16: React framework
TypeScript: Type-safe development
TanStack Query: Data fetching and caching
TanStack Table: Advanced table components
Shadcn UI: Component library
Tailwind CSS: Utility-first styling
React Hook Form: Form management with Zod validation
Recharts: Data visualization
AI SDK: AI-powered features

Getting Started

Prerequisites

Go 1.25 or higher
Node.js 20 or higher
Docker & Docker Compose (optional)
Bun or npm package manager

Environment Variables

Create a .env file in the root directory with the following variables:

# Server
PORT=8080

# Database (Turso) - Leave empty to use local SQLite
TURSO_DATABASE_URL=
TURSO_AUTH_TOKEN=

# S3-compatible storage
S3_ENDPOINT=your-s3-endpoint
S3_BUCKET=your-bucket-name
S3_ACCESS_KEY=your-access-key
S3_SECRET_KEY=your-secret-key
S3_REGION=us-east-1
S3_USE_PATH_STYLE=false

# Authentication
MCPROUTER_SERVER_URL=your-mcprouter-url
MCPROUTER_SERVER_API_KEY=your-api-key
OAUTH_SERVER_URL=your-oauth-server
OAUTH_ISSUER=your-oauth-issuer
OAUTH_AUDIENCE=your-oauth-audience

# File Server (for unlinking files)
FILE_SERVER_URL=your-file-server-url

Installation

Option 1: Using Docker Compose (Recommended)

# Start the application
docker-compose up -d

# View logs
docker-compose logs -f

# Stop the application
docker-compose down

Option 2: Local Development

Backend:

# Install dependencies
make deps

# Generate OpenAPI code
make generate

# Build the binary
make build

# Run the server
make run

# Or run with hot reload (requires air)
air

Frontend:

cd frontend

# Install dependencies
bun install

# Run development server
bun dev

# Build for production
bun build

Development Commands

Backend:

make deps           # Download and tidy dependencies
make build          # Build the binary
make run            # Run the server
make test           # Run tests
make test-e2e       # Run E2E tests
make test-coverage  # Run tests with coverage
make fmt            # Format code
make lint           # Lint code
make generate       # Generate OpenAPI code
make clean          # Clean build artifacts
make install-local  # Install binary to /usr/local/bin

Frontend:

bun dev     # Start development server
bun build   # Build for production
bun start   # Start production server
bun lint    # Run ESLint

Project Structure

.
├── cmd/
│   └── server/          # Main application entry point
├── internal/
│   ├── api/             # API server and handlers
│   │   ├── handlers/    # HTTP request handlers
│   │   ├── middleware/  # Middleware functions
│   │   └── generated/   # OpenAPI generated code
│   ├── assets/          # Static assets and OpenAPI spec
│   ├── mcp/             # Model Context Protocol server
│   ├── models/          # Database models
│   ├── services/        # Business logic services
│   ├── tools/           # MCP tools implementation
│   └── utils/           # Utility functions
├── frontend/            # Next.js frontend application
│   ├── app/             # Next.js app directory
│   │   ├── (auth)/      # Authentication pages
│   │   ├── (dashboard)/ # Dashboard pages
│   │   └── api/         # API routes
│   ├── components/      # React components
│   ├── hooks/           # Custom React hooks
│   └── lib/             # Utility libraries and API clients
├── e2e/                 # End-to-end tests
├── k8s/                 # Kubernetes deployment configs
└── oapi-codegen/        # OpenAPI code generation configs

API Documentation

The API follows OpenAPI 3.0 specification. Key endpoints include:

/api/health - Health check
/api/categories - Category management
/api/companies - Company/vendor management
/api/receivers - Invoice receiver management
/api/tags - Tag management
/api/invoices - Invoice CRUD operations
/api/invoices/{id}/items - Invoice line items
/api/upload - File upload operations
/api/analytics/* - Analytics and statistics

Full API documentation is available in internal/assets/openapi.yaml.

MCP Server

This project includes a Model Context Protocol (MCP) server that allows AI assistants to interact with the invoice management system. The MCP server provides tools for:

Creating, reading, updating, and deleting invoices
Managing categories, companies, receivers, and tags
Uploading and managing files
Generating analytics and statistics

The MCP server is automatically started alongside the main API server.

Kubernetes Deployment

Kubernetes deployment configurations are available in the k8s/ directory:

cd k8s

# Apply all configurations
kubectl apply -k .

# Or apply individually
kubectl apply -f namespace.yaml
kubectl apply -f secrets.yaml
kubectl apply -f deployment.yaml
kubectl apply -f service.yaml
kubectl apply -f ingress.yaml
kubectl apply -f cluster-issuer.yaml

See k8s/README.md for detailed deployment instructions.

Testing

Unit Tests:

make test

E2E API Tests:

make test-e2e

Coverage Report:

make test-coverage

Contributing

Fork the repository
Create a feature branch (git checkout -b feature/amazing-feature)
Commit your changes (git commit -m 'Add some amazing feature')
Push to the branch (git push origin feature/amazing-feature)
Open a Pull Request

License

This project is maintained by RxTech Lab.

Support

For issues and questions, please open an issue on GitHub.

Acknowledgments

Built with Fiber
Frontend powered by Next.js
UI components from Shadcn UI
MCP integration via mcp-go

finance

Remote

Resume MCP

v1.4.0

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 and PDF Generation

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

When calling generate_preview, you'll receive both:

A preview URL to view the resume in browser (includes a download button)
A download URL to directly download the PDF version

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

HTTP Endpoints

The server runs an HTTP API on port 8080 with the following endpoints:

GET /resume/preview/:sid - View generated HTML preview with download button
GET /resume/download/:sid - Download resume as PDF (pixel-perfect with preview)
GET /health - Health check endpoint

PDF Generation

The server supports PDF generation using headless Chrome via chromedp:

Local Mode: Uses locally installed Chrome/Chromium (automatic)
Remote Mode: Connect to remote Chrome instance via WebSocket

Environment Variables

CHROMEDP_REMOTE_URL - Optional WebSocket URL for remote Chrome (e.g., ws://chromedp:9222)
BASE_URL - Base URL for generating preview/download links (e.g., https://resume.example.com)

PDF Features

Generated PDF is pixel-perfect with web preview
Uses the same HTML and CSS styling
Download button excluded from PDF output
Stateless - PDF generated in-memory, no local files created

Kubernetes Deployment

When deploying to Kubernetes, the deployment includes a Chrome sidecar container:

# Chrome runs as a sidecar on port 9222
- name: chrome
  image: zenika/alpine-chrome:latest
  args:
    - --headless
    - --no-sandbox
    - --disable-dev-shm-usage
    - --remote-debugging-port=9222

Set CHROMEDP_REMOTE_URL=ws://localhost:9222 to use the sidecar.

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.7.0

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...