Piapi Mcp Server

What is Piapi Mcp Server about?

Piapi Mcp Server is a TypeScript‑based MCP server that bridges MCP‑compatible clients (e.g., Claude Desktop, Cursor) with PiAPI’s suite of generative AI models. It exposes a catalog of tools such as image creation, video synthesis, music generation, TTS, and 3‑D model rendering, allowing LLMs to request media content directly.

How to use Piapi Mcp Server?

1. Prerequisites – Node.js 16+, npm/yarn, and a PiAPI API key.
2. Installation – Clone the repo, install dependencies, and build:

   git clone https://github.com/apinetwork/piapi-mcp-server
   cd piapi-mcp-server
   npm install
   npm run build
   

3. Configure – Create a .env file with PIAPI_API_KEY=your_key. Add the server entry to the client’s MCP configuration (Claude Desktop or Cursor) pointing to the compiled dist/index.js.
4. Run – Start the server with node dist/index.js (or via the client’s launch command). Optionally test with the built‑in MCP Inspector (npm run inspect).

Key features of Piapi Mcp Server

• Base image and video toolkits
• Flux, Midjourney, Kling, Luma Dream Machine, Skyreels, Wan, and other model integrations
• Music generation (MMAudio, Suno) and zero‑shot TTS
• 3‑D model generation via Trellis
• Automatic contract‑backed tool generation ensuring the server stays in sync with PiAPI’s API catalog
• Drift detection and reporting workflow for API changes

Use cases of Piapi Mcp Server

• Creative assistants – Let an LLM produce illustrations, animations, or background music on‑the‑fly.
• Prototyping UI/UX – Generate placeholder graphics or demo videos directly from prompts.
• Content production pipelines – Automate generation of assets for marketing, games, or educational material.
• Research & experimentation – Quickly test different generative models through a unified MCP interface.

FAQ from the Piapi Mcp Server

Q: Do I need a separate PiAPI account for each model? A: No, a single PiAPI API key grants access to all supported models; usage limits are enforced by PiAPI.

Q: Why might video generation fail? A: Time‑consuming tasks may exceed Claude’s default timeout. Increase the timeout in the MCP Inspector URL (e.g., ?timeout=60000).

Q: Can I add new models without modifying code? A: Yes. The sync task fetches PiAPI’s OpenAPI contract, generates contract‑backed tools, and detects drift. Run npm run sync to update the catalog.

Q: Is there a way to test the server locally? A: Use the MCP Inspector (npm run inspect) which provides an interactive UI for invoking all exposed functions.

Q: How do I disable the server in Cursor? A: Open Cursor’s MCP settings, locate the “piapi” entry, and toggle the “Enabled” switch.

piapi-mcp-server

A TypeScript implementation of a Model Context Protocol (MCP) server that integrates with PiAPI's API. PiAPI makes user able to generate media content with Midjourney/Flux/Kling/LumaLabs/Udio/Chrip/Trellis directly from Claude or any other MCP-compatible apps.

Features (more coming soon)

Note: Time-consuming tools like video generation may not complete due to Claude's timeout limitations

• Base Image toolkit
• Base Video toolkit
• Flux Image generation from text/image prompt
• Hunyuan Video generation from text/image prompt
• Skyreels Video generation from image prompt
• Wan Video generation from text/image prompt
• MMAudio Music generation from video
• TTS Zero-Shot voice generation
• Midjourney Image generation
  • imagine
  • other
• Kling Video and Effects generation
• Luma Dream Machine video generation
• Suno Music generation
• Suno Lyrics generation
• Udio Music and Lyrics generation
• Trellis 3D model generation from image
• Workflow planning inside LLMs

Working with Claude Desktop Example

Prerequisites

• Node.js 16.x or higher
• npm or yarn
• A PiAPI API key (get one at piapi.ai)

Installation

Installing via Smithery

To install PiAPI MCP Server for Claude Desktop automatically via Smithery:

npx -y @smithery/cli install piapi-mcp-server --client claude

Manual Installation

1. Clone the repository:

git clone https://github.com/apinetwork/piapi-mcp-server
cd piapi-mcp-server

2. Install dependencies:

npm install

3. Build the project:

npm run build

After building, a dist/index.js file will be generated. You can then configure this file with Claude Desktop and other applications. For detailed configuration instructions, please refer to the Usage section.

4. (Optional) Test server with MCP Inspector:

First, create a .env file in the project root directory with your API key:

PIAPI_API_KEY=your_api_key_here

Then run the following command to start the MCP Inspector:

npm run inspect

After running the command, MCP Inspector will be available at http://localhost:5173 (default port: 5173). Open this URL in your browser to start testing. The default timeout for inspector operations is 10000ms (10 seconds), which may not be sufficient for image generation tasks. It's recommended to increase the timeout when testing image generation or other time-consuming operations. You can adjust the timeout by adding a timeout parameter to the URL, for example: http://localhost:5173?timeout=60000 (sets timeout to 60 seconds)

The MCP Inspector is a powerful development tool that helps you test and debug your MCP server implementation. Key features include:

• Interactive Testing: Test your server's functions directly through a web interface
• Real-time Feedback: See immediate results of your function calls and any errors that occur
• Request/Response Inspection: View detailed information about requests and responses
• Function Documentation: Browse available functions and their parameters
• Custom Parameters: Set custom timeout values and other configuration options
• History Tracking: Keep track of your previous function calls and their results

For detailed information about using the MCP Inspector and its features, visit the official MCP documentation.

Usage

Connecting to Claude Desktop

Add this to your Claude Desktop configuration file (~/Library/Application Support/Claude/claude_desktop_config.json on macOS or %APPDATA%\Claude\claude_desktop_config.json on Windows):

{
  "mcpServers": {
    "piapi": {
      "command": "node",
      "args": ["/absolute/path/to/piapi-mcp-server/dist/index.js"],
      "env": {
        "PIAPI_API_KEY": "your_api_key_here"
      }
    }
  }
}

After updating your configuration file, you need to restart Claude for Desktop. Upon restarting, you should see a hammer icon in the bottom right corner of the input box. For more detailed information, visit the official MCP documentation

Connecting to Cursor

Note: Following guide is based on Cursor 0.47.5. Features and behaviors may vary in different versions.

To configure the MCP server:

1. Navigate to: File > Preferences > Cursor Settings, or use the shortcut key Ctrl+Shift+J
2. Select "MCP" tab on the left panel
3. Click "Add new global MCP server" button in the top right
4. Add your configuration in the opened mcp.json file

{
  "mcpServers": {
    "piapi": {
      "command": "node",
      "args": ["/absolute/path/to/piapi-mcp-server/dist/index.js"],
      "env": {
        "PIAPI_API_KEY": "your_api_key_here"
      }
    }
  }
}

5. After configuration, you'll see a "piapi" entry in MCP Servers page
6. Click the Refresh button on the entry or restart Cursor to connect to the piapi server

To test the piapi image generation:

1. Open and select "Agent mode" in Cursor Chat, or use the shortcut key Ctrl+I
2. Enter a test prompt, for example: "generate image of a dog"
3. The image will be generated based on your prompt using piapi server

To disable the piapi server:

1. Navigate to the MCP Servers page in Cursor Settings
2. Find the "piapi" entry in the server list
3. Click the "Enabled" toggle button to switch it to "Disabled"

Keeping tools in sync with PiAPI (sync task)

src/index.ts registers a contract-backed MCP tool for every committed PiAPI (model, task_type) capability. Tool names are deterministic: piapi_<model>_<task_type> (for example, piapi_qubico_flux1_schnell_txt2img), and their input schemas are generated from the committed catalog. The existing hand-written convenience tools remain available; the contract-backed tools ensure the exposed surface stays complete as the Manager catalog changes.

The legacy convenience tools in src/index.ts remain hand-written, but the complete contract-backed surface is generated from the committed catalog. This repository includes a repeatable drift detector that compares that catalog baseline with PiAPI Manager's versioned API contract. It detects new APIs, deprecated APIs, parameter changes, and description changes.

Source of truth: the Go API.postman_collection.json contract in the PiAPI Manager GitHub repository (Gocyber-world/midjourney-http-v2). The task fetches that versioned contract directly from GitHub and extracts the POST /api/v1/task examples into (model, task_type) capabilities. If the Manager repository is private, set the CI secret MCP_SYNC_GITHUB_TOKEN with least-privilege contents: read on that source repository (and only the separate approved write permissions needed for MCP update automation). It has no Apidog dependency and deliberately does not inspect or report pricing.

Commands

npm run build          # compile the MCP server and sync task
npm run test:sync      # offline sync-engine tests (no network or credentials)
npm run sync           # fetch contract and diff baseline; exit 0 = in sync, 2 = drift
npm run sync:snapshot  # print the normalized current contract catalog
npm run sync:report    # write the Markdown drift report to sync-report.md
npm run sync:accept    # after updating src/index.ts, refresh the baseline

By default, npm run sync uses the Manager GitHub contract. For recovery or local development, an exported OpenAPI JSON file can be supplied instead:

node dist/sync/cli.js diff --file ./piapi-openapi.json

When a drift report is produced, a new capability is already represented by its contract-backed MCP tool after the baseline is accepted. Validate the MCP server, run npm run sync:accept, and commit the refreshed baseline. Update a hand-written convenience tool only when a curated model-specific UX is useful.

Automation

.github/workflows/sync-piapi.yml is retained for manual dispatch only. Periodic synchronization is run from the approved local automation environment, which holds the separately owner-approved MCP credential and can validate, accept, and push catalog updates after its sensitive-information gate passes.

Development

Project Structure

piapi-mcp-server/
├── assets/
├── src/
│   ├── index.ts        # Main server entry point
│   └── sync/           # PiAPI -> MCP sync task
│       ├── cli.ts          # CLI: snapshot / diff / accept / report-file
│       ├── fetchers.ts     # GitHub Postman contract + local-file sources
│       ├── normalize.ts    # OpenAPI -> (model, task_type) catalog
│       ├── diff.ts         # catalog diff + Markdown report
│       ├── catalog.ts      # baseline load/save
│       ├── selftest.ts     # offline engine test (npm run test:sync)
│       ├── types.ts
│       └── baseline.piapi-catalog.json  # committed baseline
├── .github/workflows/sync-piapi.yml     # weekly drift check
├── package.json
├── tsconfig.json
└── .env.example

License

MIT