Piapi Mcp Server

What is PiAPI MCP Server?

The ### PiAPI MCP Server is a TypeScript implementation of a Model Context Protocol (MCP) server that seamlessly integrates with PiAPI's API. This innovative server allows users to generate media content using various platforms such as Midjourney, Flux, Kling, LumaLabs, Udio, Chirp, and Trellis directly from Claude or any other MCP-compatible applications. It serves as a bridge between user commands and the media generation capabilities of these platforms, enhancing the user experience and streamlining content creation.

Features of PiAPI MCP Server

TypeScript Implementation: Built using TypeScript, ensuring type safety and better development practices.
MCP Compatibility: Fully compliant with the Model Context Protocol, allowing for easy integration with other MCP-compatible applications.
Multi-Platform Support: Supports a variety of media generation platforms, enabling users to create content across different services.
User-Friendly Interface: Designed with usability in mind, making it easy for users to generate media content without extensive technical knowledge.
Open Source: Available as a public repository, allowing developers to contribute, modify, and enhance the server's functionality.

How to Use PiAPI MCP Server

Installation: Clone the repository from GitHub and install the necessary dependencies using npm or yarn.
```
git clone https://github.com/apinetwork/piapi-mcp-server.git
cd piapi-mcp-server
npm install
```
Configuration: Set up your API keys and configuration settings in the provided configuration file to connect with the desired media generation platforms.
Running the Server: Start the server using the command:
```
npm start
```
Making Requests: Use the API endpoints provided by the server to send requests for media generation. Ensure that your requests comply with the MCP specifications.
Integration: Integrate the server with your MCP-compatible applications to start generating media content.

Frequently Asked Questions

Q1: What is the purpose of the PiAPI MCP Server?

A1: The PiAPI MCP Server acts as a mediator between users and various media generation platforms, allowing for efficient content creation through a unified API.

Q2: Is the PiAPI MCP Server free to use?

A2: Yes, the PiAPI MCP Server is open-source and available for free on GitHub.

Q3: Can I contribute to the PiAPI MCP Server?

A3: Absolutely! Contributions are welcome. You can fork the repository, make changes, and submit a pull request.

Q4: What platforms can I generate media content with?

A4: The server supports multiple platforms including Midjourney, Flux, Kling, LumaLabs, Udio, Chirp, and Trellis.

Q5: How can I report issues or request features?

A5: You can report issues or request features by opening an issue on the GitHub repository.

By utilizing the PiAPI MCP Server, users can streamline their media generation processes and enhance their creative workflows across various platforms.

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

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

Clone the repository:

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

Install dependencies:

npm install

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.

(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:

Navigate to: File > Preferences > Cursor Settings, or use the shortcut key Ctrl+Shift+J
Select "MCP" tab on the left panel
Click "Add new global MCP server" button in the top right
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"
      }
    }
  }
}

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

To test the piapi image generation:

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

To disable the piapi server:

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

Development

Project Structure

piapi-mcp-server/
├── assets/
├── src/
│   ├── index.ts        # Main server entry point
├── package.json
├── tsconfig.json
└── .env.example

License

MIT

Server Config

{
  "mcpServers": {
    "piapi-mcp-server": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "ghcr.io/metorial/mcp-container--apinetwork--piapi-mcp-server--piapi-mcp-server",
        "node dist/index.js"
      ],
      "env": {
        "PIAPI_API_KEY": "piapi-api-key"
      }
    }
  }
}