MCPfinder: Discover, Install, Monetize AI on MCP Server

Overview

MCPfinder is a server implementation that acts as an in-ecosystem app store for Model Context Protocol (MCP) hosts. It provides discovery, installation, deployment, and monetization primitives so MCP consumers and providers can share, install, and bill for AI capabilities in a consistent way. Running MCPfinder lets operators run a catalog of MCP-compatible integrations (tools, models, plugins) that clients can browse and install into their MCP host environments.

For developers and platform operators, MCPfinder centralizes common concerns: metadata and manifest hosting, versioning, signed packages, usage metering, and payment integration. This reduces the work required to publish MCP apps or to let users discover vetted capabilities without building custom catalog and billing systems.

Features

• Catalog of MCP packages with searchable metadata and semantic versioning
• Package hosting and signed manifests for integrity and provenance
• One-click install flow for MCP hosts via standard MCP manifests
• Monetization primitives (e.g., subscription plans, one-time purchases, usage metering)
• Admin dashboard and simple API for package publishing and management
• Authentication and access control for private/public packages
• Webhooks and event hooks for usage, installs, and billing notifications
• CLI and SDK examples for publishing and installing packages
• Support for sandboxed deployments and staged rollouts

Installation / Configuration

Below are general steps to get MCPfinder running. Adjust environment variables and persistence to match your infrastructure.

1. Clone repository and install dependencies (Node.js example)

git clone https://github.com/mcpfinder/server.git
cd server
# Install (Node.js)
npm ci

2. Environment variables (example .env)

PORT=3000
DATABASE_URL=postgres://user:pass@localhost:5432/mcpfinder
REDIS_URL=redis://localhost:6379
JWT_SECRET=<your-jwt-secret>
STRIPE_API_KEY=<optional-stripe-api-key-for-payments>
MCP_SIGNING_KEY=<optional-signing-key-for-manifests>

3. Database migrations and seed data (example with a migration tool)

# run migrations
npm run migrate

# seed admin user (if provided)
npm run seed

4. Start server

npm start
# or in development
npm run dev

5. Docker / docker-compose (minimal example)

version: "3.8"
services:
  mcpfinder:
    image: mcpfinder/server:latest
    ports:
      - "3000:3000"
    environment:
      - DATABASE_URL=postgres://user:pass@postgres:5432/mcpfinder
      - REDIS_URL=redis://redis:6379
      - JWT_SECRET=supersecret
  postgres:
    image: postgres:14
    environment:
      - POSTGRES_DB=mcpfinder
      - POSTGRES_USER=user
      - POSTGRES_PASSWORD=pass
  redis:
    image: redis:7

After starting, visit http://localhost:3000 (or the configured host) to access the web dashboard and API.

Available Resources

• API endpoints (examples)

• Package manifest format (example)

{
  "name": "text-summarizer",
  "version": "1.2.0",
  "mcp_schema": "1.0",
  "entrypoints": [
    { "type": "api", "url": "https://example.com/summarize" }
  ],
  "permissions": ["read_context", "write_response"],
  "billing": {
    "plan_id": "plan_monthly_001",
    "price_cents": 500
  }
}

• SDKs & CLI: Publish, sign, and test manifests with the included CLI (see /cli/ in repo) and example clients for common MCP runtimes.
• Admin Dashboard: Publish packages, configure plans, view installs and usage metrics, and manage keys.

Use Cases

1. Internal AI catalog for a company

   • Host private MCP packages (e.g., connectors to internal data sources, fine-tuned models) behind authentication. Developers discover approved capabilities and install them directly into their MCP hosts without manual onboarding.

2. Monetizing a model or plugin

   • A third-party developer publishes a premium summarization plugin with a subscription plan. MCPfinder handles checkout and issues install tokens to paying customers. Usage metrics drive billing reconciliation.

3. Community marketplace

   • Open-source authors publish packages with signed manifests. Hosts can automatically pull trusted community capabilities and track versions and changelogs.

4. Controlled rollout and versioning

   • Publish new versions of an MCP integration and use staged releases to roll out to a subset of hosts. Use webhooks to receive install events and automate compatibility tests.

Getting Started Tips

• Create a signing key and configure it in production to ensure integrity of published manifests.
• Use database backups and Redis persistence for durable state (billing and installs).
• Integrate Stripe (or another payment provider) behind the billing webhook to reconcile payments and unlock installs.
• Start with a small catalog and use role-based access control for early adopters before opening to the public.

For detailed API documentation, CLI usage, and manifest schema, see the repository README and the project’s docs directory on GitHub: https://github.com/mcpfinder/server.