# MCP & Skills

> Source: https://www.memelord.com/hackers/mcp (HTML). Dev Portal index: https://www.memelord.com/hackers/llms.txt

Connect Memelord to your AI tools via MCP (Model Context Protocol). Search templates, generate and edit image and video memes, run one-shot image tools, or hand a whole request to Jester — directly from Claude, ChatGPT, Cursor, Claude Code, Windsurf, and any other MCP client.

The tool surface mirrors what Jester can do in the Memelord app today: every tool returns results as URLs for your client to use or download. There is no folder or collection storage over MCP. To use your own photos or clips, `upload_media` saves them to your Uploads and returns a URL the other tools accept.

## MCP Server

The Memelord MCP server is hosted at `https://www.memelord.com/api/mcp` (Streamable HTTP). No installation needed. Two ways to authenticate:

- **Sign in with your browser (OAuth)** — the default for desktop and web clients. Add the URL, click Connect, approve the request on the consent screen, done.
- **API key** — for scripts, CI, and headless agents where nobody can click through a login.

### Option A: Connect with your browser (recommended)

Add the server URL with no headers. Your client discovers Memelord's authorization server automatically, opens a browser window, and asks you to sign in to Memelord and approve the connection. Tokens refresh themselves; disconnect anytime from Settings → Developer → Connected Apps (https://www.memelord.com/settings/developer).

Access tokens last an hour and your client renews them in the background with a refresh token, so you should only see the sign-in window once. If it keeps coming back, something ended your Memelord session: changing your password signs out every device and every connected app, and so does disconnecting the app under Connected Apps. A sign-out that applies to all of your devices (the iOS app currently does this) ends connected apps' sessions too; signing out of the website only signs out that browser.

**Claude Code**

```bash
claude mcp add --transport http memelord https://www.memelord.com/api/mcp
```

**Claude (desktop / web)**: Settings → Connectors → Add custom connector → paste `https://www.memelord.com/api/mcp` → Connect.

**ChatGPT**: Settings → Connectors → Create (Developer mode) → MCP Server URL `https://www.memelord.com/api/mcp` → Authentication: OAuth.

**Cursor**: add to `.cursor/mcp.json` (or Settings → MCP → Add), then click the login prompt Cursor shows:

```json
{
  "mcpServers": {
    "memelord": {
      "url": "https://www.memelord.com/api/mcp"
    }
  }
}
```

### Option B: API key (scripts and headless agents)

Create a key in Developer Settings (https://www.memelord.com/settings/developer) — it starts with `mlord_live_` — and send it as a bearer token. API-key sessions get a slightly smaller tool set; see "API keys and company integrations" below.

```json
{
  "mcpServers": {
    "memelord": {
      "type": "http",
      "url": "https://www.memelord.com/api/mcp",
      "headers": {
        "Authorization": "Bearer mlord_live_YOUR_API_KEY"
      }
    }
  }
}
```

**Windsurf / other tools**: any tool that supports remote MCP servers over Streamable HTTP can connect. Point it at `https://www.memelord.com/api/mcp`; it will either run the OAuth flow or accept an `Authorization` header with your API key.

### Connect Muse

Muse has no MCP settings form. Instead, it builds the connector itself when you ask. In Muse, paste this prompt into a chat:

```
Create a Custom Connector for a remote MCP server. Name: Memelord. Transport: streamable HTTP. URL: https://www.memelord.com/api/mcp. Auth: OAuth 2.1 with PKCE, no API key. Dynamic client registration is supported; metadata at https://www.memelord.com/.well-known/oauth-authorization-server. Use your built-in connector feature if you have one, and show me the sign-in link.
```

Open the sign-in link Muse gives you and approve the connection. Muse may still ask for an API key; you don't need one for this.

If Muse can't finish OAuth, create an API key in Developer Settings, then paste this prompt into a new chat instead:

```
Build a custom connector to Memelord. Its MCP server is https://www.memelord.com/api/mcp, a hosted public HTTPS streamable-HTTP endpoint. Auth: Authorization: Bearer header.
```

When Muse asks for the key, paste it only into its secure credential prompt. Never paste your API key into the chat itself.

### Start making memes

Ask your AI assistant in natural language:

```
"What meme templates are trending right now?"

"Generate a meme about developers fixing bugs at 3am"

"Make a video meme about shipping on Friday"

"Edit the last meme to be about JavaScript instead"

"Face-swap me onto the Drake template using this photo URL"
```

### Using your own photos and videos

Tools take media as public URLs. When you hand your assistant a local file, it uploads it first with `upload_media`, which saves it to your Uploads and returns an https URL (valid for 7 days). JPEG, PNG, and WebP images up to 10 MB and MP4, MOV, and WebM videos up to 100 MB are accepted; uploads are free and limited to 50 per hour.

- `data_base64` — the file inline, up to 3 MB.
- `source_url` — an https link Memelord downloads. ChatGPT attachments arrive this way automatically.
- Larger files — `create_media_upload_url` returns a one-time upload URL; PUT the bytes, then call `upload_media` with the `upload_id`.

```bash
curl -X PUT -H "Content-Type: video/mp4" \
  --data-binary @clip.mp4 "<upload_url>"
```

## API keys and company integrations

An API key is how a company puts Memelord behind its own product: one key, one shared usage balance, and any number of its own users behind it. Two things differ from an OAuth session:

- **A smaller tool set.** `upload_media`, `create_media_upload_url`, `list_video_jobs` are not available with an API key (they are absent from `tools/list`, and calling them returns an error). Pass media as public https URLs, and keep the `job_id`s the video tools return — `check_video_status` still works. Everything else, including every pro video model, is identical.
- **Optional end-user attribution.** Send `X-Memelord-End-User` with an opaque id for the end user behind the call (your user id or a hash — letters, digits, `_ . : -`, up to 128 characters; never an email or a name). If your SDK cannot set headers, put the same value in `_meta.end_user_id` on the `tools/call`. The header is optional: a call without it is billed to your shared balance exactly as before, and a call with it is billed the same way, just attributed to that end user on your usage records. `get_account` echoes the `end_user_id` the session received, so you can confirm the header landed.

```json
{
  "mcpServers": {
    "memelord": {
      "type": "http",
      "url": "https://www.memelord.com/api/mcp",
      "headers": {
        "Authorization": "Bearer mlord_live_YOUR_API_KEY",
        "X-Memelord-End-User": "your-user-id-or-hash"
      }
    }
  }
}
```

## Available Tools

Tools marked **Billable** draw from your usage balance based on the underlying generation cost. Everything else — search, template lookup, trending, tool discovery, media uploads, render status, and account info — is free so your agent can plan before it spends.

| Group | Tool | Purpose | Cost | API key |
| --- | --- | --- | --- | --- |
| Discovery | `search_memes` | Search the template library (memes, videos, stickers) by meaning, keyword, or similar image | Free | Yes |
| Discovery | `get_meme_template` | Fetch one template's metadata, text slots, and media URL by id | Free | Yes |
| Discovery | `get_trending_memes` | Current trending templates with cultural context | Free | Yes |
| Discovery | `list_image_tools` | Catalog of one-shot image tools (face swaps, filters, generators) runnable via run_image_tool | Free | Yes |
| Media uploads | `upload_media` | Upload your own photo or video to your Memelord Uploads and get an https URL to pass to the media tools | Free | OAuth only |
| Media uploads | `create_media_upload_url` | Get a direct PUT URL for files over 3 MB, then finish with upload_media | Free | OAuth only |
| Image memes | `generate_caption_meme` | New text on a real classic meme template — the image itself is never AI-edited | Billable | Yes |
| Image memes | `generate_ai_meme` | AI-remixed memes: the template picture is edited to fit the joke, optionally with your reference images | Billable | Yes |
| Image memes | `edit_meme` | Edit the text on a previously generated image meme | Billable | Yes |
| Video memes | `generate_video_meme` | Generate captioned video memes (async render jobs) | Billable | Yes |
| Video memes | `edit_video_meme` | Re-caption an existing video meme | Billable | Yes |
| Video memes | `check_video_status` | Poll one render job and get the MP4 URL when complete | Free | Yes |
| Video memes | `list_video_jobs` | List your recent render jobs with status and MP4 URLs | Free | OAuth only |
| Pro video models | `list_video_models` | Catalog of AI video models (Kling 3.0, Kling O3, Seedance, Wan 3.0, Cinema Studio 4.0), Genjutsu, and Gemini Omni, with required inputs and params | Free | Yes |
| Pro video models | `run_video_model` | Generate AI footage with one model from list_video_models from a prompt, start frame, or references (async job) | Billable | Yes |
| Pro video models | `run_genjutsu` | Put a person or character into an existing video clip, keeping its motion, camera, and audio (async job) | Billable | Yes |
| Pro video models | `run_gemini_omni` | Gemini Omni, Google's Gemini video model: edit an existing clip with an instruction, animate a still, or generate a short clip from a prompt (async job) | Billable | Yes |
| Agent & tools | `run_agent` | Hand a natural-language request to Jester, Memelord's full agent (search, caption, edit, generate, video, face swap) | Billable | Yes |
| Agent & tools | `run_image_tool` | Run one specific image tool from list_image_tools on an input image or prompt | Billable | Yes |
| Account | `get_account` | Who am I, usage balance, and how this session is authenticated | Free | Yes |

Check spend on Settings → Usage (https://www.memelord.com/settings/usage). If the balance hits zero, billable tools return a clear error and the free tools keep working.

Every tool in the table that API keys can use is also a plain REST endpoint with the same key — see the Tools API section of the API Docs (https://www.memelord.com/hackers/docs.md).

## Authentication details

- `/api/mcp` is an OAuth 2.1 protected resource. Its metadata lives at `https://www.memelord.com/.well-known/oauth-protected-resource/api/mcp` (RFC 9728), and an unauthenticated request gets a `401` with a `WWW-Authenticate` challenge pointing there. Compliant clients need nothing else to start the flow.
- The authorization server is Memelord's own sign-in (Supabase Auth), so you use your existing account — email, Google, or Apple. Clients register themselves dynamically (RFC 7591); PKCE is required.
- Every token acts as you, with the same permissions the website has. There are no per-tool scopes: free tools never spend, billable tools are gated by your usage balance, and you can revoke an app at any time.
- API keys are tied to your account and can be revoked individually in Developer Settings. Keep them out of repos and chat logs.

## OpenClaw Skill

Alternatively, the Memelord skill is available on OpenClaw for tools that support it. Install it and set your API key as an environment variable:

```bash
openclaw install iamjasonlevin/memelord
export MEMELORD_API_KEY="mlord_live_YOUR_API_KEY"
```

The OpenClaw skill works with Cursor, Claude Code, Windsurf, Codex, and any OpenClaw-compatible agent. Listing: https://clawhub.ai/iamjasonlevin/memelord