AI Image Generation Server with MCP Interface

by aymec

2 stars
220 downloads
Not rated
GitHub

About

This project provides an HTTP server for image generation using Stable Diffusion, along with a Model Context Protocol (MCP) server that enables AI agents to request image generation.

Details

Author
aymec
GitHub stars
2
Downloads
220
Categories
Media

- Combined MCP server and image generation service
- Uses Stable Diffusion for text-to-image generation
- Provides a direct HTTP API for image generation
- Returns image URL, dimensions, format, and metadata
- Runs on port 5000 by default (customizable)
- Supports integration with Goose and the FastMCP Inspector

Setting up with Highlight

This MCP is not yet compatible with Highlight’s one-click setup. However, you can still use it with Highlight by following these steps:

  1. Download and install Highlight from highlightai.com/download
  2. Navigate to the plugins tab and select "Add Custom Plugin"
  3. Configure the plugin with the settings below
    Plugin Name AI Image Generation Server with MCP Interface
    Command (node, npx, python, etc.)

    Please refer to the README for specific instructions on how to obtain API keys or other required environment variables.

  4. Enable "Start Automatically" if you want the plugin to start when Highlight launches

From the repository

Set up a virtual environment (mandatorily named .venv), install the MCP package (pip install -e .), then run the combined service with image-gen-mcp after setting the IMAGE_GEN_DIR environment variable. Alternatively, use development mode with the FastMCP Inspector for testing and debugging. Integrate with Goose as a StandardIO extension by providing the executable path and the IMAGE_GEN_DIR variable.

Claude Desktop / Cursor

Paste into your MCP client config file to install this server.

{
    "mcpServers": {
        "ai image generation server with mcp interface": {
            "image_gen_with_mcp": {
                "command": "python",
                "args": [
                    "generate_image.py"
                ]
            }
        }
    }
}

McpServers

{
    "image_gen_with_mcp": {
        "command": "python",
        "args": [
            "generate_image.py"
        ]
    }
}
# AI Image Generation Server with MCP Interface This project provides a Model Context Protocol (MCP) server with integrated Stable Diffusion image generation capabilities, enabling AI agents to request and receive generated images. This project is based on the example provided by [Block's Goose Custom Extension tutorial](https://block.github.io/goose/docs/tutorials/custom-extensions/). ## Setup 1. Create a virtual environment, use `.venv` mandatorily: ```bash virtualenv .venv ``` 2. Activate the virtual environment: ```bash source .venv/bin/activate ``` 3. Install the MCP package (for Goose integration): ```bash pip install -e . ``` ## Running the Service The MCP server includes the integrated image generation service. You can start both with a single command: **Standard mode:** ```bash source .venv/bin/activate # Activate your virtualenv export IMAGE_GEN_DIR=/absolute/path/to/folder # Set generated images target folder image-gen-mcp ``` **Development mode with FastMCP Inspector:** Open two terminals: Terminal 1 ```bash source .venv/bin/activate # Activate your virtualenv export IMAGE_GEN_DIR=/absolute/path/to/folder # Set generated images target folder image-gen-mcp # Start image generation service (and a MCP server we won't use) ``` Terminal 2 ```bash source .venv/bin/activate # Activate your virtualenv export IMAGE_GEN_DIR=/absolute/path/to/folder # Set generated images target folder mcp dev src/image_gen_mcp/server.py # Start MCP server with Inspector ``` Note: Only when using development mode, the image generation service must be started separately. This will start the MCP server with the FastMCP Inspector, which provides: 1. A web interface at http://127.0.0.1:6274 for testing and debugging 2. A proxy server on port 6277 for forwarding MCP requests **Using the FastMCP Inspector:** 1. Open http://127.0.0.1:6274 in your browser 2. Use the interactive interface to: - Explore available tools and their documentation - Test the `generate_image` tool with your own prompts - View request/response history - Debug any issues with the MCP server **Custom port for image generation service:** ```bash source .venv/bin/activate # Activate your virtualenv export IMAGE_GEN_DIR=/absolute/path/to/folder # Set generated images target folder image-gen-mcp --port 5001 ``` ## Direct API Access Generate an image by sending a POST request to the image generation service: ```bash curl -X POST http://localhost:5000/generate \ -H "Content-Type: application/json" \ -d '{"prompt": "A futuristic cityscape at sunset"}' ``` The response will include the URL to access the generated image along with metadata: ```json { "type": "image", "format": "png", "url": "http://localhost:5000/images/123e4567-e89b-12d3-a456-426614174000.png", "width": 512, "height": 512, "filename": "123e4567-e89b-12d3-a456-426614174000.png", "filepath": "generated_images/123e4567-e89b-12d3-a456-426614174000.png", "mime_type": "image/png", "prompt": "A futuristic cityscape at sunset", "alt_text": "AI-generated image of: A futuristic cityscape at sunset" } ``` You can access the generated image directly via the returned `image_url`. ## File Organization - `src/image_gen_mcp/` - Package directory containing the implementation - `server.py` - The MCP server implementation - `generator.py` - The image generation service - `__init__.py` - Package initialization and CLI entry point - `__main__.py` - Enables running the package as a module ## Integration with Goose To add this MCP server as an extension in Goose: 1. Go to `Settings > Extensions > Add`. 2. Set the `Type` to `StandardIO`. 3. Provide ID "image_generator", name "Image Generator", and an appropriate description. 4. In the `Command` field, provide the absolute path to your executable: ``` uv run /full/path/to/your/project/.venv/bin/image-gen-mcp ``` 5. Add an environment variable `IMAGE_GEN_DIR` and pick a folder where generated images will be stored Once integrated, you can use the image generation tool in Goose by asking it to generate an image with a specific prompt. It works immediately when using OpenAI GPT-4o. It is possible to run everytthing locally with Ollama, After trying a few models, the only one that worked is [mistral-small3.1](https://ollama.com/library/mistral-small3.1). Even on a high-end MacBookPro, the response from mistral-small3.1 is much slower than with OpenAI GPT-4o. ## Service Architecture Both services are integrated into a single application: 1. **Image Generation Service** (src/image_gen_mcp/generator.py) - Handles the actual image generation using Stable Diffusion - Provides a simple HTTP API for image generation - Returns image URL, dimensions, and metadata - Includes a direct endpoint to serve the generated images - Runs on port 5000 by default (customizable with --port) - Runs in a separate thread within the same process as the MCP server 2. **MCP Server** (src/image_gen_mcp/server.py) - Provides a standardized MCP interface for AI agents - Forwards requests to the integrated Image Generation Service - Returns a properly formatted MCP image object with URL and metadata ## Stopping the Service Use Ctrl+C to stop both services, as they now run within the same process.
No reviews yet — be the first

Sign in to leave a review

Use Google, GitHub, or an email account so ratings stay tied to real people.

Email sign in

No reviews posted yet.