# Memelord MCP

```json
{
  "name": "Memelord MCP",
  "slug": "memelord_mcp",
  "url": "https://composio.dev/toolkits/memelord_mcp",
  "markdown_url": "https://composio.dev/toolkits/memelord_mcp.md",
  "logo_url": "https://www.memelord.com/favicon.ico",
  "categories": [
    "entertainment & media"
  ],
  "is_composio_managed": false,
  "updated_at": "2026-10-19T05:33:25.443Z"
}
```

![Memelord MCP logo](https://www.memelord.com/favicon.ico)

## Description

Securely connect your AI agents and chatbots (Claude, ChatGPT, Cursor, etc) with Memelord MCP or direct API to search meme templates, generate image and video memes, edit media, and check jobs through natural language.

## Summary

Memelord MCP is a hosted meme creation service for searching templates and working with image and video memes.
It provides one MCP connection for discovery, generation, editing, uploads, and Jester.

## Categories

- entertainment & media

## Toolkit Details

- Tools: 19

## Images

- Logo: https://www.memelord.com/favicon.ico

## Authentication

- **Dcr Oauth**
  - Type: `custom`
  - Description: Dcr Oauth authentication for Memelord MCP.
  - Setup:
    - Configure Dcr Oauth credentials for Memelord MCP.
    - Use the credentials when creating an auth config in Composio.
- **Api Key**
  - Type: `api_key`
  - Description: Api Key authentication for Memelord MCP.
  - Setup:
    - Configure Api Key credentials for Memelord MCP.
    - Use the credentials when creating an auth config in Composio.

## Suggested Prompts

- Search meme templates for reaction images
- Generate a captioned meme from a template
- Check your meme generation job status

## Supported Tools

| Tool slug | Name | Description |
|---|---|---|
| `MEMELORD_MCP_CHECK_VIDEO_STATUS` | Check video status | Check one video job from any video-producing tool. Returns status (pending / processing → completed \| failed) and the MP4 download URL once complete. Free — poll every few seconds after a tool returns a job_id. |
| `MEMELORD_MCP_CREATE_MEDIA_UPLOAD_URL` | Create media upload url | Start a direct upload for a file too large to send inline (over 3 MB), typically a video. Returns an upload_url and upload_id: PUT the raw file bytes to upload_url with the returned Content-Type header (for example curl -X PUT -H "Content-Type: video/mp4" --data-binary @clip.mp4 ""), then call upload_media with upload_id to get the file's url. The upload_url expires after 2 hours. Accepts image/jpeg, image/png, image/webp, video/mp4, video/quicktime, video/webm; images up to 10 MB, videos up to 100 MB. Free. |
| `MEMELORD_MCP_EDIT_MEME` | Edit meme | Change the text of an image meme you already generated. Pass the edit_handle from a generate_caption_meme / generate_ai_meme (or previous edit_meme) result together with a plain-language instruction; use the slot numbers from that result's caption_slots as target_index to change just one box. Re-renders the image and returns a fresh URL, the updated caption_slots, and a new edit_handle (earlier handles stay valid, so you can branch from any version). Handles only work for the account that created them. Billed against your usage balance. |
| `MEMELORD_MCP_EDIT_VIDEO_MEME` | Edit video meme | Rewrite the caption of a video meme and re-render it. Provide the template_id and the current caption from a previous generate_video_meme job plus a plain-language instruction. Starts a new render job — poll check_video_status for the MP4. Billed against your usage balance. |
| `MEMELORD_MCP_GENERATE_AI_MEME` | Generate ai meme | AI-remixed image memes: Jester picks a meme template (or uses template_id), AI-edits the picture itself to fit the joke — swapping subjects, adding objects, or painting in people and products from reference_image_urls — then captions it. Use generate_caption_meme instead when you only want new text on an unchanged classic template. Returns signed image URLs plus template_id, caption_slots, and an edit_handle for edit_meme. Billed against your usage balance. |
| `MEMELORD_MCP_GENERATE_CAPTION_MEME` | Generate caption meme | Classic caption memes: Jester picks a real meme template from the library (or uses template_id), writes new text for its caption slots, and renders that text on the unchanged template image. The picture is never AI-edited or repainted — use generate_ai_meme for that. Returns signed image URLs plus template_id, caption_slots, and an edit_handle you can hand to edit_meme to change the wording. Use search_memes or get_trending_memes first if you want to pick the template yourself. Billed against your usage balance. |
| `MEMELORD_MCP_GENERATE_VIDEO_MEME` | Generate video meme | Generate AI-captioned video memes from a topic. Jester picks video templates (or uses template_id), writes the caption text, and starts render jobs. Rendering is asynchronous: this returns job_ids immediately — poll check_video_status (or list_video_jobs) until status is "completed" to get the MP4 URL. Billed against your usage balance. |
| `MEMELORD_MCP_GET_ACCOUNT` | Get account | Return the authenticated Memelord account: user id, display name, email, usage balance (USD, rounded to cents), whether billable tools can run, where to add credits, and how this MCP session is authenticated (OAuth or API key). Call this to confirm who you are acting as or to check whether billable tools will succeed. Free. |
| `MEMELORD_MCP_GET_MEME_TEMPLATE` | Get meme template | Fetch one template asset by id: name, type (meme \| video \| sticker), media URL, description, tags, dimensions, and how many text slots its layout has. Use it to inspect a search result before generating with template_id. Free. |
| `MEMELORD_MCP_GET_TRENDING_MEMES` | Get trending memes | What's trending right now: the most recent curated trending templates with a short cultural-context blurb explaining the format. Use it to pick timely templates for generate_caption_meme / generate_ai_meme / generate_video_meme, or to answer "what memes are hot this week". NSFW drops are never included. Free. |
| `MEMELORD_MCP_LIST_IMAGE_TOOLS` | List image tools | Catalog of one-shot image tools you can run with run_image_tool: celebrity face swaps (Trump, Elon, Zuck, Vance, …), filters (Bust Down, Wojakify, GigaChad, Looksmaxxing, mugshot, Windows 95), and text-to-image generators (mascots, logos, Pokémon-style cards). Each entry lists its tool_id, whether it needs an image and/or a prompt, and any extra params. Free. |
| `MEMELORD_MCP_LIST_VIDEO_JOBS` | List video jobs | List your recent video jobs from every video tool, newest first, with status and MP4 URLs. Use it to recover job_ids after a reconnect or to find finished videos without polling each job. Statuses are as last recorded; call check_video_status on an in-progress job to refresh it. Free. |
| `MEMELORD_MCP_LIST_VIDEO_MODELS` | List video models | List the pro AI video models this account can run — Kling 3.0, Kling O3, Seedance, Wan 3.0, Cinema Studio 4.0 (run with run_video_model) — and Genjutsu character transpose (run with run_genjutsu). Each entry lists required and optional inputs, rules, and params (options, ranges, defaults). Call this before run_video_model to pick a model and valid params. Free. |
| `MEMELORD_MCP_RUN_AGENT` | Run agent | Hand a natural-language request to Jester, Memelord's full meme agent — the same brain behind the Memelord chat. Jester decides what to do: search templates, caption a meme, remix a format, edit or generate an image, face-swap, make or caption a video, add text-to-speech or lipsync, convert to GIF, and more. Use this when a request does not map cleanly onto a specific tool ("turn this photo into a 3-panel meme about my cat", "make a video meme with the drake format about Mondays", "put my face on Elon"). Pass thread_id from a previous result to continue the conversation. Returns the assistant's message plus any images; videos come back as job_ids to poll with check_video_status. Billed against your usage balance. |
| `MEMELORD_MCP_RUN_GENJUTSU` | Run genjutsu | Genjutsu character transpose: put a person or character into an existing video clip while keeping its motion, choreography, camera, timing, and audio ("put me in this music video", "swap the dancer for my character"). Needs the source clip (video_url, or video_job_id of a finished video on this account) and 1-8 photos of who to put in (character_image_urls). Both must be real media the user provided — never invent, guess, or substitute URLs. When the user gives you local photos or a local clip, upload each with upload_media first (clips over 3 MB via create_media_upload_url) and pass the returned urls. If anything is missing the call returns status "needs_input" listing everything still needed, with nothing started or charged: ask the user once, then call again. To generate new footage use run_video_model; for meme-template video clips use generate_video_meme. Returns a job_id; poll check_video_status until completed. Billed against your usage balance per second of the source clip, only once the job starts. |
| `MEMELORD_MCP_RUN_IMAGE_TOOL` | Run image tool | Run one specific image tool from list_image_tools by tool_id — e.g. "donald-trump-face-swapper" with a face photo, "bust-down-filter" on a portrait, or "mascot-generator" with a prompt. Provide image_url for image-to-image tools, prompt for text-to-image tools, and params for any extra inputs the tool lists. Returns the resulting image URL(s). Prefer this over run_agent when you already know exactly which tool you want. Billed against your usage balance. |
| `MEMELORD_MCP_RUN_VIDEO_MODEL` | Run video model | Generate new AI video footage with one model from list_video_models: from a prompt alone, a start frame (image_url, optional end_image_url), or reference images / clips / audio. Use this for original footage ("a cinematic drone shot over Tokyo at night", "animate this photo"). For a meme template turned into a captioned video clip use generate_video_meme; for still images use run_image_tool or generate_ai_meme; to put a person into an existing clip use run_genjutsu. Media must be public URLs the user provided — never invent or guess them; if the user gave you local files, upload them with upload_media and pass the returned url. Invalid requests come back as status "invalid_request" listing every problem, with nothing charged. Returns a job_id; poll check_video_status until completed (usually a few minutes). Billed against your usage balance per generated second, only once the job starts. |
| `MEMELORD_MCP_SEARCH_MEMES` | Search memes | Search Memelord's template library of memes, video clips, and stickers. Default method "semantic_context" matches what a meme MEANS or depicts (natural-language queries like "when the deploy works on the first try"). Use "fulltext" for exact names and proper nouns ("drake", "spongebob"), "fuzzy" for misspellings, "semantic_combined" when visual identity matters, or "semantic_media" with media_url to find templates that look like a given image. Results come best match first and include ids you can pass as template_id to generate_caption_meme / generate_ai_meme / generate_video_meme / get_meme_template. Paging: each response has has_more and next_offset; to get the next page, repeat the exact same call (same query, method, filters, limit, min_score) with offset set to next_offset, and stop when has_more is false (next_offset is null). Pass ids you already have in exclude_ids only when starting a fresh search, not while paging, or the pages shift. Free. |
| `MEMELORD_MCP_UPLOAD_MEDIA` | Upload media | Upload the user's own photo or video into their Memelord Uploads and get back an https url to pass to generate_ai_meme reference_image_urls, run_image_tool image_url, run_agent image_urls, run_genjutsu character_image_urls / video_url, or run_video_model image and reference fields. Use it whenever the user gives you a local file or an attachment instead of a public link — never invent or guess media URLs. Send exactly one of: data_base64 (file bytes, up to 3 MB decoded), source_url (an https link to download), file (a host-provided file), or upload_id (after PUTting a larger file to the upload_url from create_media_upload_url). Accepts image/jpeg, image/png, image/webp, video/mp4, video/quicktime, video/webm; images up to 10 MB, videos up to 100 MB. Genjutsu uses 4-30 s of a source clip (longer clips are trimmed to 30 s) and clear, front-facing photos work best for character_image_urls. The url is valid for 7 days; calling upload_media again with the same upload_id returns a fresh one. Free, and limited to 50 uploads per hour. |

## Supported Triggers

None listed.

## Installation and MCP Setup

### Path 1: SDK Installation

#### Path 1, Step 1: Install Composio

Install the Composio SDK, the OpenAI provider, and the OpenAI SDK
```python
pip install composio composio_openai openai
```

```typescript
npm install @composio/core @composio/openai openai
```

#### Path 1, Step 2: Create a Composio session

Initialize Composio with the OpenAI Responses provider and create a session scoped to Memelord MCP
```python
import json
from openai import OpenAI
from composio import Composio
from composio_openai import OpenAIResponsesProvider

composio = Composio(provider=OpenAIResponsesProvider())
client = OpenAI()

session = composio.create(user_id="your-user-id", toolkits=["memelord_mcp"])
tools = session.tools()
```

```typescript
import OpenAI from "openai";
import { Composio } from "@composio/core";
import { OpenAIResponsesProvider } from "@composio/openai";

const composio = new Composio({ provider: new OpenAIResponsesProvider() });
const client = new OpenAI();

const session = await composio.create("your-user-id", { toolkits: ["memelord_mcp"] });
const tools = await session.tools();
```

#### Path 1, Step 3: Run Memelord MCP tools with your agent

Send a request, execute the Memelord MCP tool calls through the session, and print the final answer
```python
response = client.responses.create(
    model="gpt-5.6-sol",
    tools=tools,
    input=[{"role": "user", "content": "Search Memelord for distracted boyfriend meme templates and show me the best options"}],
)

while True:
    tool_calls = [o for o in response.output if o.type == "function_call"]
    if not tool_calls:
        break
    results = composio.provider.handle_tool_calls(response=response, session=session)
    response = client.responses.create(
        model="gpt-5.6-sol",
        tools=tools,
        previous_response_id=response.id,
        input=[
            {"type": "function_call_output", "call_id": call.call_id, "output": json.dumps(results[i])}
            for i, call in enumerate(tool_calls)
        ],
    )

print(response.output_text)
```

```typescript
let response = await client.responses.create({
  model: "gpt-5.6-sol",
  tools,
  input: [{ role: "user", content: "Search Memelord for distracted boyfriend meme templates and show me the best options" }],
});

while (response.output.some((o) => o.type === "function_call")) {
  const outputs = await composio.provider.handleToolCalls(session, response.output);
  response = await client.responses.create({
    model: "gpt-5.6-sol",
    tools,
    previous_response_id: response.id,
    input: outputs,
  });
}

console.log(response.output_text);
```

### Path 2: MCP Server Setup

#### Path 2, Step 1: Install Composio

Install the Composio SDK and your agent framework
```python
pip install composio claude-agent-sdk
```

```typescript
npm install @composio/core ai @ai-sdk/mcp @ai-sdk/openai
```

#### Path 2, Step 2: Create a session with MCP enabled

Create a session scoped to Memelord MCP and read its MCP URL and headers
```python
from composio import Composio

composio = Composio()
session = composio.create(user_id="your-user-id", toolkits=["memelord_mcp"], mcp=True)
```

```typescript
import { Composio } from "@composio/core";

const composio = new Composio();
const { mcp } = await composio.create("your-user-id", {
  toolkits: ["memelord_mcp"],
  mcp: true,
});
```

#### Path 2, Step 3: Connect your agent to the MCP server

Pass the session's MCP URL and headers to your agent and run a Memelord MCP request
```python
import asyncio
from claude_agent_sdk import ClaudeSDKClient, ClaudeAgentOptions, AssistantMessage, TextBlock

options = ClaudeAgentOptions(
    mcp_servers={
        "composio": {
            "type": "http",
            "url": session.mcp.url,
            "headers": session.mcp.headers,
        }
    },
    system_prompt="You are a helpful assistant with access to Memelord MCP tools.",
    tools=[],
    allowed_tools=["mcp__composio__*"],
)

async def main():
    async with ClaudeSDKClient(options=options) as client:
        await client.query("Search Memelord for distracted boyfriend meme templates and show me the best options")
        async for message in client.receive_response():
            if isinstance(message, AssistantMessage):
                for block in message.content:
                    if isinstance(block, TextBlock):
                        print(block.text)

asyncio.run(main())
```

```typescript
import { createMCPClient } from "@ai-sdk/mcp";
import { openai } from "@ai-sdk/openai";
import { generateText, stepCountIs } from "ai";

const client = await createMCPClient({
  transport: { type: "http", url: mcp.url, headers: mcp.headers },
});

const { text } = await generateText({
  model: openai("gpt-5.6-sol"),
  tools: await client.tools(),
  prompt: "Search Memelord for distracted boyfriend meme templates and show me the best options",
  stopWhen: stepCountIs(10),
});

console.log(text);
await client.close();
```

## Why Use Composio?

### 1. AI Native Memelord MCP Integration

- Supports Memelord MCP and direct API integrations for meme discovery and creation
- Structured, LLM-friendly schemas for searching templates, generating media, and checking jobs
- Rich coverage for image memes, video memes, uploads, Jester, and account information

### 2. Managed Auth

- Connect your own Memelord MCP OAuth or API key credentials securely
- Central place to manage, scope, and revoke Memelord MCP access
- Per user and per environment credentials instead of hard-coded keys

### 3. Agent Optimized Design

- Tools are tuned using real error and success rates to improve reliable template searches and media jobs
- Comprehensive execution logs so you always know what ran, when, and on whose behalf

### 4. Enterprise Grade Security

- Fine-grained RBAC so you control which agents and users can access Memelord MCP
- Scoped, least privilege access to Memelord MCP media and account resources
- Full audit trail of agent actions to support review and compliance

## Use Memelord MCP with any AI Agent Framework

Choose a framework you want to connect Memelord MCP with:

- [ChatGPT](https://composio.dev/toolkits/memelord_mcp/framework/chatgpt)
- [Claude Cowork](https://composio.dev/toolkits/memelord_mcp/framework/claude-cowork)
- [Hermes](https://composio.dev/toolkits/memelord_mcp/framework/hermes-agent)
- [Atomic Agent](https://composio.dev/toolkits/memelord_mcp/framework/atomic-agent)

## Related Toolkits

- [Youtube](https://composio.dev/toolkits/youtube) - YouTube is a leading video-sharing platform for uploading, streaming, and discovering content. It empowers creators and businesses to reach global audiences and monetize their work.
- [AllTrails MCP](https://composio.dev/toolkits/alltrails_mcp) - AllTrails MCP is a trail discovery service for hiking, biking, and running routes. Use it to find reviewed trails, photos, maps, difficulty info, and route details fast.
- [Amara](https://composio.dev/toolkits/amara) - Amara is a collaborative platform for creating and managing subtitles and captions for videos. It helps make content accessible and multilingual for global audiences.
- [Captions](https://composio.dev/toolkits/captions) - Captions provides the Mirage API for generating videos, speech, and styled captions. Use it to automate polished video creation, voiceovers, and captioning from one API.
- [Cats](https://composio.dev/toolkits/cats) - Cats is an API with a huge library of cat images, breed data, and cat facts. It makes finding adorable cat photos and trivia effortless for your apps and users.
- [Chatfai](https://composio.dev/toolkits/chatfai) - Chatfai is an AI platform that lets users talk to AI versions of fictional characters from books, movies, and games. It offers an engaging, interactive experience for fans to chat, roleplay, and explore creative dialogues.
- [Cincopa](https://composio.dev/toolkits/cincopa) - Cincopa is a multimedia platform for uploading, managing, and customizing videos, images, and audio. It helps you deliver engaging media experiences with robust APIs and flexible integrations.
- [Descript MCP](https://composio.dev/toolkits/descript_mcp) - Descript MCP is a media processing and project workflow service for creators and teams. It streamlines media import, automated processing, and job management.
- [Dungeon fighter online](https://composio.dev/toolkits/dungeon_fighter_online) - Dungeon Fighter Online (DFO) is an arcade-style, side-scrolling action RPG packed with dynamic combat and progression. Play solo or with friends to battle monsters, complete quests, and upgrade your characters.
- [Elevenlabs](https://composio.dev/toolkits/elevenlabs) - Elevenlabs is an advanced AI voice generation platform for lifelike, multilingual speech synthesis. Perfect for creating natural voices for videos, apps, and business content in seconds.
- [Elevenreader](https://composio.dev/toolkits/elevenreader) - Elevenreader is an AI-powered text-to-speech service by ElevenLabs that converts written content into lifelike audio. It enables fast, natural audio generation from any text.
- [Epic games](https://composio.dev/toolkits/epic_games) - Epic Games is a leading video game publisher and digital storefront, known for Fortnite and Unreal Engine. It lets gamers access, manage, and purchase games all in one place.
- [Eranol](https://composio.dev/toolkits/eranol) - Eranol is an API-driven media conversion service for video, audio, and FFmpeg workflows. It helps teams automate reliable transcoding, format conversion, and media processing at scale.
- [Fal.ai](https://composio.dev/toolkits/fal_ai) - Fal.ai is a generative media platform offering 600+ AI models for images, video, voice, and audio. Developers use Fal.ai for fast, scalable access to cutting-edge generative AI tools.
- [Giphy](https://composio.dev/toolkits/giphy) - Giphy is the largest online library for searching and sharing GIFs and stickers. Instantly add vibrant animated content to your apps, chats, and workflows.
- [Headout](https://composio.dev/toolkits/headout) - Headout is a global platform for booking travel experiences, tours, and entertainment. It helps users discover and secure activities at top destinations, all in one place.
- [Imagekit io](https://composio.dev/toolkits/imagekit_io) - ImageKit.io is a cloud-based media management platform for image and video delivery. Instantly optimize, transform, and deliver visuals globally via a lightning-fast CDN.
- [Listennotes](https://composio.dev/toolkits/listennotes) - Listennotes is a powerful podcast search engine with a massive global database. Discover, search, and curate podcasts from around the world in seconds.
- [News api](https://composio.dev/toolkits/news_api) - News api is a REST API for searching and retrieving live news articles from across the web. Instantly access headlines, coverage, and breaking stories from thousands of sources.
- [RAWG Video Games Database](https://composio.dev/toolkits/rawg_video_games_database) - RAWG Video Games Database is the largest video game discovery and info service. Instantly access comprehensive details, ratings, and release dates for thousands of games.

## Frequently Asked Questions

### Do I need my own developer credentials to use Memelord MCP with Composio?

Yes, Memelord MCP requires you to configure your own Dcr Oauth credentials. Once set up, Composio handles secure credential storage and management for you.

### Can I use multiple toolkits together?

Yes! Composio's Tool Router enables agents to use multiple toolkits. [Learn more](https://docs.composio.dev/tool-router/overview).

### Is Composio secure?

Composio is SOC 2 and ISO 27001 compliant with all data encrypted in transit and at rest. [Learn more](https://trust.composio.dev).

### What if the API changes?

Composio maintains and updates all toolkit integrations automatically, so your agents always work with the latest API versions.

---
[See all toolkits](https://composio.dev/toolkits) · [Composio docs](https://docs.composio.dev/llms.txt)