Meme MCP Server

by 0x8687

Overview Schema Related Servers Score Discussions

TypeScript

connect-gmail

Connect to Gmail to enable meme generation with user-specific email data through the Meme MCP Server.

Instructions

Connect to Gmail

Input Schema

TableJSON Schema

Name	Required	Description	Default
No arguments

Implementation Reference

src/tools.ts:12-36 (handler)

The handler function for the 'connect-gmail' tool. It initiates a Gmail connection using the Composio VercelAIToolSet by getting an entity for 'default-user' and calling initiateConnection with appName 'gmail'. It returns a response with the redirect URL for OAuth connection or an error message.

server.tool("connect-gmail", "Connect to Gmail", {}, async (args, extra) => {
    try {
        console.log('args ', args);
        console.log('extra ', extra);
        const userAddress = "default-user";
        
        const entity = toolset.client.getEntity(userAddress);
        const connection = await entity.initiateConnection({ appName: "gmail" });
        
        return {
            content: [{ 
                type: "text", 
                text: `🔗 Gmail connection initiated!\n\nPlease connect your Gmail account by clicking on the link below:\n\n${connection.redirectUrl}\n\nAfter connecting, you can use Gmail actions.` 
            }],
        };
    } catch (error) {
        console.error('Error initiating Gmail connection:', error);
        return {
            content: [{ 
                type: "text", 
                text: `Error initiating Gmail connection: ${error instanceof Error ? error.message : String(error)}` 
            }],
        };
    }
});

src/tools.ts:12-36 (registration)

Registration of the 'connect-gmail' tool using server.tool, with empty schema {}, description 'Connect to Gmail', and inline handler.

server.tool("connect-gmail", "Connect to Gmail", {}, async (args, extra) => {
    try {
        console.log('args ', args);
        console.log('extra ', extra);
        const userAddress = "default-user";
        
        const entity = toolset.client.getEntity(userAddress);
        const connection = await entity.initiateConnection({ appName: "gmail" });
        
        return {
            content: [{ 
                type: "text", 
                text: `🔗 Gmail connection initiated!\n\nPlease connect your Gmail account by clicking on the link below:\n\n${connection.redirectUrl}\n\nAfter connecting, you can use Gmail actions.` 
            }],
        };
    } catch (error) {
        console.error('Error initiating Gmail connection:', error);
        return {
            content: [{ 
                type: "text", 
                text: `Error initiating Gmail connection: ${error instanceof Error ? error.message : String(error)}` 
            }],
        };
    }
});

src/tools.ts:10-684 (helper)

The registerTools function registers all MCP tools including connect-gmail, using the toolset initialized from VercelAIToolSet.

export function registerTools(server: McpServer) {
    // Authentication & Connection Tools
    server.tool("connect-gmail", "Connect to Gmail", {}, async (args, extra) => {
        try {
            console.log('args ', args);
            console.log('extra ', extra);
            const userAddress = "default-user";
            
            const entity = toolset.client.getEntity(userAddress);
            const connection = await entity.initiateConnection({ appName: "gmail" });
            
            return {
                content: [{ 
                    type: "text", 
                    text: `🔗 Gmail connection initiated!\n\nPlease connect your Gmail account by clicking on the link below:\n\n${connection.redirectUrl}\n\nAfter connecting, you can use Gmail actions.` 
                }],
            };
        } catch (error) {
            console.error('Error initiating Gmail connection:', error);
            return {
                content: [{ 
                    type: "text", 
                    text: `Error initiating Gmail connection: ${error instanceof Error ? error.message : String(error)}` 
                }],
            };
        }
    });

    server.tool("check-gmail-connection", "Check Gmail connection status", {}, async (args, extra) => {
        try {
            console.log('args ', args);
            console.log('extra ', extra);
            
            const userAddress = "default-user";
            
            const result = await toolset.executeAction({
                action: "GMAIL_GET_PROFILE",
                entityId: userAddress,
                params: {}
            });
            
            if (result.successful) {
                const profile = result.data?.response_data as any;
                return {
                    content: [{ 
                        type: "text", 
                        text: `✅ Your Gmail account is connected!\n\nUser Profile:\n• Email: ${profile.emailAddress}\n• Messages: ${profile.messagesTotal} total\n• Threads: ${profile.threadsTotal} total` 
                    }],
                };
            } else {
                return {
                    content: [{ 
                        type: "text", 
                        text: "❌ Your Gmail account is not connected! Please use the connect-gmail tool first." 
                    }],
                };
            }
        } catch (error) {
            console.error('Error checking Gmail connection:', error);
            return {
                content: [{ 
                    type: "text", 
                    text: `Error checking Gmail connection: ${error instanceof Error ? error.message : String(error)}` 
                }],
            };
        }
    });

    // Email Operations
    server.tool("send-email", "Send an email", {
        to: z.string().describe("The email address of the recipient"),
        subject: z.string().describe("The subject of the email"),
        body: z.string().describe("The body of the email"),
    }, async (args, extra) => {    
        try {
            const userAddress = "default-user";
            
            const result = await toolset.executeAction({
                action: "GMAIL_SEND_EMAIL",
                entityId: userAddress,
                params: args
            });
            
            if (result.successful) {
                return {
                    content: [{ 
                        type: "text", 
                        text: `✅ Email sent successfully!\n\nTo: ${args.to}\nSubject: ${args.subject}\n\nYour email has been sent and is now in your Gmail sent folder.` 
                    }],
                };
            } else {
                return {
                    content: [{ 
                        type: "text", 
                        text: `❌ Failed to send email: ${result.error || 'Unknown error'}` 
                    }],
                };
            }
        } catch (error) {
            console.error('Error sending email:', error);
            return {
                content: [{ 
                    type: "text", 
                    text: `Error sending email: ${error instanceof Error ? error.message : String(error)}` 
                }],
            };
        }
    });

    server.tool("get-emails", "Get emails from inbox", {
        maxResults: z.number().optional().describe("Maximum number of emails to retrieve (default: 10)"),
        query: z.string().optional().describe("Gmail search query to filter emails"),
        labelIds: z.array(z.string()).optional().describe("Array of label IDs to filter by"),
    }, async (args, extra) => {
        try {
            const userAddress = "default-user";
            
            const result = await toolset.executeAction({
                action: "GMAIL_GET_EMAILS",
                entityId: userAddress,
                params: args
            });
            
            if (result.successful) {
                const emails = result.data?.response_data as any;
                const emailList = emails.messages?.map((email: any) => 
                    `• ${email.snippet} (${email.id})`
                ).join('\n') || 'No emails found';
                
                return {
                    content: [{ 
                        type: "text", 
                        text: `📧 Emails retrieved successfully!\n\n${emailList}\n\nTotal: ${emails.messages?.length || 0} emails` 
                    }],
                };
            } else {
                return {
                    content: [{ 
                        type: "text", 
                        text: `❌ Failed to get emails: ${result.error || 'Unknown error'}` 
                    }],
                };
            }
        } catch (error) {
            console.error('Error getting emails:', error);
            return {
                content: [{ 
                    type: "text", 
                    text: `Error getting emails: ${error instanceof Error ? error.message : String(error)}` 
                }],
            };
        }
    });

    server.tool("get-email", "Get a specific email by ID", {
        emailId: z.string().describe("The ID of the email to retrieve"),
    }, async (args, extra) => {
        try {
            const userAddress = "default-user";
            
            const result = await toolset.executeAction({
                action: "GMAIL_GET_EMAIL",
                entityId: userAddress,
                params: args
            });
            
            if (result.successful) {
                const email = result.data?.response_data as any;
                return {
                    content: [{ 
                        type: "text", 
                        text: `📧 Email Details:\n\nFrom: ${email.payload?.headers?.find((h: any) => h.name === 'From')?.value}\nSubject: ${email.payload?.headers?.find((h: any) => h.name === 'Subject')?.value}\nDate: ${email.payload?.headers?.find((h: any) => h.name === 'Date')?.value}\n\nBody: ${email.snippet}` 
                    }],
                };
            } else {
                return {
                    content: [{ 
                        type: "text", 
                        text: `❌ Failed to get email: ${result.error || 'Unknown error'}` 
                    }],
                };
            }
        } catch (error) {
            console.error('Error getting email:', error);
            return {
                content: [{ 
                    type: "text", 
                    text: `Error getting email: ${error instanceof Error ? error.message : String(error)}` 
                }],
            };
        }
    });

    server.tool("reply-to-email", "Reply to an existing email", {
        emailId: z.string().describe("The ID of the email to reply to"),
        message: z.string().describe("The reply message content"),
    }, async (args, extra) => {
        try {
            const userAddress = "default-user";
            
            const result = await toolset.executeAction({
                action: "GMAIL_REPLY_TO_EMAIL",
                entityId: userAddress,
                params: args
            });
            
            if (result.successful) {
                return {
                    content: [{ 
                        type: "text", 
                        text: `✅ Reply sent successfully!\n\nYour reply has been sent to the original email thread.` 
                    }],
                };
            } else {
                return {
                    content: [{ 
                        type: "text", 
                        text: `❌ Failed to send reply: ${result.error || 'Unknown error'}` 
                    }],
                };
            }
        } catch (error) {
            console.error('Error sending reply:', error);
            return {
                content: [{ 
                    type: "text", 
                    text: `Error sending reply: ${error instanceof Error ? error.message : String(error)}` 
                }],
            };
        }
    });

    server.tool("forward-email", "Forward an email to other recipients", {
        emailId: z.string().describe("The ID of the email to forward"),
        to: z.string().describe("The email address to forward to"),
        message: z.string().optional().describe("Additional message to include with the forward"),
    }, async (args, extra) => {
        try {
            const userAddress = "default-user";
            
            const result = await toolset.executeAction({
                action: "GMAIL_FORWARD_EMAIL",
                entityId: userAddress,
                params: args
            });
            
            if (result.successful) {
                return {
                    content: [{ 
                        type: "text", 
                        text: `✅ Email forwarded successfully!\n\nForwarded to: ${args.to}` 
                    }],
                };
            } else {
                return {
                    content: [{ 
                        type: "text", 
                        text: `❌ Failed to forward email: ${result.error || 'Unknown error'}` 
                    }],
                };
            }
        } catch (error) {
            console.error('Error forwarding email:', error);
            return {
                content: [{ 
                    type: "text", 
                    text: `Error forwarding email: ${error instanceof Error ? error.message : String(error)}` 
                }],
            };
        }
    });

    // Draft Operations
    server.tool("create-draft", "Create an email draft", {
        to: z.string().describe("The email address of the recipient"),
        subject: z.string().describe("The subject of the email"),
        body: z.string().describe("The body of the email"),
    }, async (args, extra) => {
        try {
            const userAddress = "default-user";
            
            const result = await toolset.executeAction({
                action: "GMAIL_DRAFT_EMAIL",
                entityId: userAddress,
                params: args
            });
            
            if (result.successful) {
                return {
                    content: [{ 
                        type: "text", 
                        text: `📝 Draft created successfully!\n\nDraft ID: ${(result.data?.response_data as any)?.id}\nTo: ${args.to}\nSubject: ${args.subject}` 
                    }],
                };
            } else {
                return {
                    content: [{ 
                        type: "text", 
                        text: `❌ Failed to create draft: ${result.error || 'Unknown error'}` 
                    }],
                };
            }
        } catch (error) {
            console.error('Error creating draft:', error);
            return {
                content: [{ 
                    type: "text", 
                    text: `Error creating draft: ${error instanceof Error ? error.message : String(error)}` 
                }],
            };
        }
    });

    server.tool("send-draft", "Send a draft email", {
        draftId: z.string().describe("The ID of the draft to send"),
    }, async (args, extra) => {
        try {
            const userAddress = "default-user";
            
            const result = await toolset.executeAction({
                action: "GMAIL_SEND_DRAFT",
                entityId: userAddress,
                params: args
            });
            
            if (result.successful) {
                return {
                    content: [{ 
                        type: "text", 
                        text: `✅ Draft sent successfully!\n\nYour draft has been sent and is now in your Gmail sent folder.` 
                    }],
                };
            } else {
                return {
                    content: [{ 
                        type: "text", 
                        text: `❌ Failed to send draft: ${result.error || 'Unknown error'}` 
                    }],
                };
            }
        } catch (error) {
            console.error('Error sending draft:', error);
            return {
                content: [{ 
                    type: "text", 
                    text: `Error sending draft: ${error instanceof Error ? error.message : String(error)}` 
                }],
            };
        }
    });

    // Label Operations
    server.tool("get-labels", "Get all Gmail labels", {}, async (args, extra) => {
        try {
            const userAddress = "default-user";
            
            const result = await toolset.executeAction({
                action: "GMAIL_GET_LABELS",
                entityId: userAddress,
                params: {}
            });
            
            if (result.successful) {
                const labels = result.data?.response_data as any;
                const labelList = labels.labels?.map((label: any) => 
                    `• ${label.name} (${label.id})`
                ).join('\n') || 'No labels found';
                
                return {
                    content: [{ 
                        type: "text", 
                        text: `🏷️ Labels retrieved successfully!\n\n${labelList}\n\nTotal: ${labels.labels?.length || 0} labels` 
                    }],
                };
            } else {
                return {
                    content: [{ 
                        type: "text", 
                        text: `❌ Failed to get labels: ${result.error || 'Unknown error'}` 
                    }],
                };
            }
        } catch (error) {
            console.error('Error getting labels:', error);
            return {
                content: [{ 
                    type: "text", 
                    text: `Error getting labels: ${error instanceof Error ? error.message : String(error)}` 
                }],
            };
        }
    });

    server.tool("create-label", "Create a new Gmail label", {
        name: z.string().describe("The name of the label to create"),
        labelListVisibility: z.string().optional().describe("Visibility of the label in the label list"),
        messageListVisibility: z.string().optional().describe("Visibility of the label in the message list"),
    }, async (args, extra) => {
        try {
            const userAddress = "default-user";
            
            const result = await toolset.executeAction({
                action: "GMAIL_CREATE_LABEL",
                entityId: userAddress,
                params: args
            });
            
            if (result.successful) {
                return {
                    content: [{ 
                        type: "text", 
                        text: `✅ Label created successfully!\n\nLabel: ${args.name}\nID: ${(result.data?.response_data as any)?.id}` 
                    }],
                };
            } else {
                return {
                    content: [{ 
                        type: "text", 
                        text: `❌ Failed to create label: ${result.error || 'Unknown error'}` 
                    }],
                };
            }
        } catch (error) {
            console.error('Error creating label:', error);
            return {
                content: [{ 
                    type: "text", 
                    text: `Error creating label: ${error instanceof Error ? error.message : String(error)}` 
                }],
            };
        }
    });

    // Thread Operations
    server.tool("get-threads", "Get email threads", {
        maxResults: z.number().optional().describe("Maximum number of threads to retrieve"),
        query: z.string().optional().describe("Gmail search query to filter threads"),
    }, async (args, extra) => {
        try {
            const userAddress = "default-user";
            
            const result = await toolset.executeAction({
                action: "GMAIL_GET_THREADS",
                entityId: userAddress,
                params: args
            });
            
            if (result.successful) {
                const threads = result.data?.response_data as any;
                const threadList = threads.threads?.map((thread: any) => 
                    `• Thread ${thread.id} (${thread.snippet})`
                ).join('\n') || 'No threads found';
                
                return {
                    content: [{ 
                        type: "text", 
                        text: `🧵 Threads retrieved successfully!\n\n${threadList}\n\nTotal: ${threads.threads?.length || 0} threads` 
                    }],
                };
            } else {
                return {
                    content: [{ 
                        type: "text", 
                        text: `❌ Failed to get threads: ${result.error || 'Unknown error'}` 
                    }],
                };
            }
        } catch (error) {
            console.error('Error getting threads:', error);
            return {
                content: [{ 
                    type: "text", 
                    text: `Error getting threads: ${error instanceof Error ? error.message : String(error)}` 
                }],
            };
        }
    });

    // Search Operations
    server.tool("search-emails", "Search emails using Gmail search syntax", {
        query: z.string().describe("Gmail search query (e.g., 'from:example@gmail.com', 'subject:meeting', 'is:unread')"),
        maxResults: z.number().optional().describe("Maximum number of results to return"),
    }, async (args, extra) => {
        try {
            const userAddress = "default-user";
            
            const result = await toolset.executeAction({
                action: "GMAIL_SEARCH_EMAILS",
                entityId: userAddress,
                params: args
            });
            
            if (result.successful) {
                const emails = result.data?.response_data as any;
                const emailList = emails.messages?.map((email: any) => 
                    `• ${email.snippet} (${email.id})`
                ).join('\n') || 'No emails found matching your search';
                
                return {
                    content: [{ 
                        type: "text", 
                        text: `🔍 Search results for "${args.query}":\n\n${emailList}\n\nTotal: ${emails.messages?.length || 0} emails found` 
                    }],
                };
            } else {
                return {
                    content: [{ 
                        type: "text", 
                        text: `❌ Failed to search emails: ${result.error || 'Unknown error'}` 
                    }],
                };
            }
        } catch (error) {
            console.error('Error searching emails:', error);
            return {
                content: [{ 
                    type: "text", 
                    text: `Error searching emails: ${error instanceof Error ? error.message : String(error)}` 
                }],
            };
        }
    });

    // Advanced Operations
    server.tool("mark-as-read", "Mark emails as read", {
        emailIds: z.array(z.string()).describe("Array of email IDs to mark as read"),
    }, async (args, extra) => {
        try {
            const userAddress = "default-user";
            
            const result = await toolset.executeAction({
                action: "GMAIL_MARK_AS_READ",
                entityId: userAddress,
                params: args
            });
            
            if (result.successful) {
                return {
                    content: [{ 
                        type: "text", 
                        text: `✅ Emails marked as read successfully!\n\nMarked ${args.emailIds.length} email(s) as read.` 
                    }],
                };
            } else {
                return {
                    content: [{ 
                        type: "text", 
                        text: `❌ Failed to mark emails as read: ${result.error || 'Unknown error'}` 
                    }],
                };
            }
        } catch (error) {
            console.error('Error marking emails as read:', error);
            return {
                content: [{ 
                    type: "text", 
                    text: `Error marking emails as read: ${error instanceof Error ? error.message : String(error)}` 
                }],
            };
        }
    });

    server.tool("mark-as-unread", "Mark emails as unread", {
        emailIds: z.array(z.string()).describe("Array of email IDs to mark as unread"),
    }, async (args, extra) => {
        try {
            const userAddress = "default-user";
            
            const result = await toolset.executeAction({
                action: "GMAIL_MARK_AS_UNREAD",
                entityId: userAddress,
                params: args
            });
            
            if (result.successful) {
                return {
                    content: [{ 
                        type: "text", 
                        text: `✅ Emails marked as unread successfully!\n\nMarked ${args.emailIds.length} email(s) as unread.` 
                    }],
                };
            } else {
                return {
                    content: [{ 
                        type: "text", 
                        text: `❌ Failed to mark emails as unread: ${result.error || 'Unknown error'}` 
                    }],
                };
            }
        } catch (error) {
            console.error('Error marking emails as unread:', error);
            return {
                content: [{ 
                    type: "text", 
                    text: `Error marking emails as unread: ${error instanceof Error ? error.message : String(error)}` 
                }],
            };
        }
    });

    server.tool("move-to-trash", "Move emails to trash", {
        emailIds: z.array(z.string()).describe("Array of email IDs to move to trash"),
    }, async (args, extra) => {
        try {
            const userAddress = "default-user";
            
            const result = await toolset.executeAction({
                action: "GMAIL_MOVE_TO_TRASH",
                entityId: userAddress,
                params: args
            });
            
            if (result.successful) {
                return {
                    content: [{ 
                        type: "text", 
                        text: `🗑️ Emails moved to trash successfully!\n\nMoved ${args.emailIds.length} email(s) to trash.` 
                    }],
                };
            } else {
                return {
                    content: [{ 
                        type: "text", 
                        text: `❌ Failed to move emails to trash: ${result.error || 'Unknown error'}` 
                    }],
                };
            }
        } catch (error) {
            console.error('Error moving emails to trash:', error);
            return {
                content: [{ 
                    type: "text", 
                    text: `Error moving emails to trash: ${error instanceof Error ? error.message : String(error)}` 
                }],
            };
        }
    });

    server.tool("get-gmail-settings", "Get Gmail settings", {}, async (args, extra) => {
        try {
            const userAddress = "default-user";
            
            const result = await toolset.executeAction({
                action: "GMAIL_GET_SETTINGS",
                entityId: userAddress,
                params: {}
            });
            
            if (result.successful) {
                const settings = result.data?.response_data as any;
                return {
                    content: [{ 
                        type: "text", 
                        text: `⚙️ Gmail Settings:\n\n${JSON.stringify(settings, null, 2)}` 
                    }],
                };
            } else {
                return {
                    content: [{ 
                        type: "text", 
                        text: `❌ Failed to get Gmail settings: ${result.error || 'Unknown error'}` 
                    }],
                };
            }
        } catch (error) {
            console.error('Error getting Gmail settings:', error);
            return {
                content: [{ 
                    type: "text", 
                    text: `Error getting Gmail settings: ${error instanceof Error ? error.message : String(error)}` 
                }],
            };
        }
    });
}

Tool Definition Quality

C2.2/5.0

Behavior1/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Connect to Gmail' reveals nothing about what the operation actually does: whether it authenticates, establishes a session, returns connection status, requires specific permissions, has side effects, or what happens on failure. For a zero-parameter tool with no annotation coverage, this complete lack of behavioral information is inadequate.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness3/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is extremely concise at just three words, but this brevity comes at the cost of meaningful information. While technically 'front-loaded' (the entire description is the first and only phrase), it fails to earn its place by providing insufficient guidance. The structure is minimal but not effectively communicative for tool selection.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given zero parameters and no annotations or output schema, the description should provide complete operational context but fails to do so. 'Connect to Gmail' doesn't explain what the tool returns, what state changes occur, or how it integrates with the 15 sibling Gmail tools. For a connection/authentication tool in a rich ecosystem, this minimal description leaves critical gaps about the tool's role and behavior.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool has zero parameters with 100% schema description coverage, so the baseline score is 4. The description doesn't need to compensate for any parameter documentation gaps since there are no parameters to document. While it doesn't add parameter-specific information (because none exist), it doesn't detract from the complete schema coverage either.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose2/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description 'Connect to Gmail' is essentially a tautology that restates the tool name 'connect-gmail' without adding meaningful specificity. It doesn't explain what 'connect' means operationally (e.g., authenticate, establish session, verify credentials) or what resource is being connected to beyond the obvious Gmail service. While it mentions the target service, it lacks a clear verb+resource combination that distinguishes it from sibling tools like 'check-gmail-connection'.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives. It doesn't explain prerequisites (e.g., whether authentication is required), when this should be called relative to other operations, or how it differs from 'check-gmail-connection'. With multiple sibling tools for Gmail operations, the absence of any usage context leaves the agent guessing about appropriate invocation scenarios.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Install Server

Other Tools

Latest Blog Posts

Tool Definition Quality Score (TDQS)
By punkpeye on April 3, 2026.
mcp
The Hackers Who Tracked My Sleep Cycle
By punkpeye on March 26, 2026.
security
Open Source Has a Bot Problem
By punkpeye on March 19, 2026.
open source

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/0x8687/mcp-gmail-v1'

If you have feedback or need assistance with the MCP directory API, please join our Discord server