openai-gpt-image-1-mcp

# MCP Server Configuration
HOST=0.0.0.0
PORT=8050
TRANSPORT=sse

# OpenAI API Configuration
OPENAI_API_KEY=your_openai_api_key

# Storage Configuration
# Set to 'local' to store images on the server, or 'supabase' to use Supabase Storage
STORAGE_MODE=supabase

# Supabase Configuration (required if STORAGE_MODE=supabase)
SUPABASE_URL=https://your-project-url.supabase.co
SUPABASE_KEY=your-supabase-service-key
SUPABASE_BUCKET=your-bucket-name

# Optional settings for image generation
# MODEL_NAME=gpt-image-1
# DEFAULT_IMAGE_SIZE=auto
# DEFAULT_IMAGE_QUALITY=auto

docker run --env-file .env -p 8050:8050 openai-gpt-image-1-mcp

python src/main.py

{
  "mcpServers": {
    "openai-gpt-image-1": {
      "transport": "sse",
      "url": "http://localhost:8050/sse"
    }
  }
}

{
  "mcpServers": {
    "openai-gpt-image-1": {
      "command": "python",
      "args": ["path/to/openai-gpt-image-1-mcp/src/main.py"],
      "env": {
        "TRANSPORT": "stdio",
        "OPENAI_API_KEY": "your_openai_api_key"
      }
    }
  }
}

{
  "mcpServers": {
    "openai-gpt-image-1": {
      "command": "docker",
      "args": ["run", "--rm", "-i", 
               "-e", "TRANSPORT", 
               "-e", "OPENAI_API_KEY", 
               "openai-gpt-image-1-mcp"],
      "env": {
        "TRANSPORT": "stdio",
        "OPENAI_API_KEY": "your_openai_api_key"
      }
    }
  }
}

# Generate an image of a flying cat with Supabase storage
# Make sure STORAGE_MODE=supabase in your .env file
result = await generate_image(
    prompt="A photorealistic flying cat with wings soaring through clouds",
    size="1024x1024",
    quality="high"
)

# Get the public URL for the image
image_url = result['image_url']        # URL to view the image
download_url = result['download_url']  # URL to download the image
filename = result['filename']          # Filename of the generated image
storage_path = result['storage_path']  # Path in Supabase storage

print(f"Image generated successfully!")
print(f"View the image at: {image_url}")

# Example of displaying the image in a web application
html_img = f'<img src="{image_url}" alt="Flying cat">'

# Example of creating a download link
html_download = f'<a href="{download_url}" download="{filename}">Download Image</a>'

# Generate an image with local storage
# Make sure STORAGE_MODE=local in your .env file
result = await generate_image(
    prompt="A photorealistic flying cat with wings soaring through clouds",
    size="1024x1024",
    quality="high",
    return_image=True  # Get the image data directly (default is True)
)

# When using local storage, you get file paths and optional base64 data
saved_path = result['saved_path']        # Absolute path on server
relative_path = result['relative_path']  # Relative path from working directory
filename = result['filename']            # Filename of the generated image
directory = result['directory']          # Directory where images are stored

# If return_image=True, you also get image data
image_data = result['image_data']  # Base64 encoded image data
mime_type = result['mime_type']    # "image/png"

# Save image from base64 data
import base64
with open(f"local-{filename}", "wb") as f:
    f.write(base64.b64decode(image_data))

print(f"Image saved locally as: local-{filename}")

# Edit an existing image to add a hat
result = await edit_image(
    prompt="Add a wizard hat to the cat",
    image_paths=["/path/to/cat_image.png"],
    size="1024x1024",
    quality="high"
)

# Check storage mode used
storage_mode = result['storage_mode']  # "supabase" or "local"

if storage_mode == "supabase":
    # Access the image via public URL
    image_url = result['image_url']
    print(f"View edited image at: {image_url}")
else:
    # When using local storage
    saved_path = result['saved_path']
    
    # If return_image=True was used, you can also access the image data
    if 'image_data' in result:
        image_data = result['image_data']
        # Save locally from base64 data
        import base64
        with open(f"edited-{result['filename']}", "wb") as f:
            f.write(base64.b64decode(image_data))

# Generate image without returning the base64 data
result = await generate_image(
    prompt="A photorealistic flying cat with wings soaring through clouds",
    return_image=False  # Don't include image data in the response
)

# Now you only have path information
saved_path = result['saved_path']
filename = result['filename']

docker run -v $(pwd)/ai-images:/app/ai-images --env-file .env -p 8050:8050 openai-gpt-image-1-mcp