Skip to main content
Glama

Slander MCP

An MCP server that finds humorous roasts, jokes, and memes about any character (real or fictional) by searching Twitter/X. Uses social proof (engagement metrics) to rank content, with targeted LLM involvement for query generation, batch quality assessment, and nickname extraction.

Installation

npm install
npm run build

Related MCP server: twitter-voice-mcp

Configuration

Create a .env file with:

# Twitter/X API credentials (required)
TWITTER_BEARER_TOKEN=your_twitter_bearer_token_here

# LLM API key (at least one required)
ANTHROPIC_API_KEY=your_anthropic_api_key_here
# or
OPENAI_API_KEY=your_openai_api_key_here

Usage with Claude Desktop

Add to your Claude Desktop MCP configuration:

{
  "mcpServers": {
    "slander": {
      "command": "node",
      "args": ["/path/to/slander_mcp/dist/index.js"],
      "env": {
        "TWITTER_BEARER_TOKEN": "your_token",
        "ANTHROPIC_API_KEY": "your_key"
      }
    }
  }
}

Tools

generate_search_query

Generate effective Twitter search queries for finding slander about a target.

Input:

  • target (string, required): Name of character to search for

Output:

  • queries: Array of search query strings

Example:

Input:  { "target": "LeBron James" }
Output: { "queries": ["LeBron James ratio", "LeChoke", "LeBron hairline", ...] }

fetch_posts

Fetch posts from Twitter for a given query, looping until quality threshold is met.

Input:

  • query (string, required): Search query

  • loop_limit (number, optional): Max fetch iterations (default: 5)

  • count (number, optional): Posts per fetch (default: 10)

  • target (string, optional): Target name for quality evaluation

Output:

  • posts: Array of post objects with engagement metrics

  • iterations: Number of fetch loops

  • stopped_reason: "quality_threshold" or "loop_limit"

rank_posts

Rank fetched posts by engagement, separate text from media, extract nicknames.

Input:

  • posts (array, required): Posts from fetch_posts

  • top_n (number, optional): Results per category (default: 3)

  • target (string, optional): Target name for nickname extraction

Output:

  • text_posts: Top text posts ranked by engagement

  • media_posts: Top media posts ranked by engagement

  • nicknames: Extracted nicknames/slang for the target

Engagement Score Formula:

score = (likes * 1.0) + (retweets * 2.0) + (replies * 0.5)

Example Workflow

  1. Generate search queries:

    generate_search_query({ target: "LeBron James" })
  2. Fetch posts for each query:

    fetch_posts({ query: "LeChoke", target: "LeBron James" })
  3. Combine and rank results:

    rank_posts({ posts: [...all_posts], top_n: 5, target: "LeBron James" })

License

MIT

Available Tools

3 tools
fetch_postsA

Fetch posts from Twitter for a given query, looping until quality threshold is met. Uses AI to evaluate batch quality and stops early when sufficient roast content is found. Returns posts with engagement metrics.

Inputs: query (required), loop_limit, count, target.

generate_search_queryC

Generate effective Twitter search queries for finding slander, roasts, jokes, and memes about a target character (real or fictional). Uses AI to produce creative, context-aware queries that capture character-specific slander.

Inputs: target (required).

rank_postsA

Rank fetched posts by engagement, separate text from media posts, and extract nicknames. Uses engagement formula: (likes * 1.0) + (retweets * 2.0) + (replies * 0.5). Retweets weighted highest because sharing is strong signal for humor.

Inputs: posts (required), top_n, target.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A3.7/5.0

    Scored across 3 tools

    Disambiguation5/5

    Each tool has a clearly distinct purpose in the slander-finding workflow: generate_search_query creates queries, fetch_posts retrieves posts based on those queries, and rank_posts processes and ranks the fetched posts. There is no overlap or ambiguity between their functions.

    Naming Consistency5/5

    All tool names follow a consistent verb_noun pattern (fetch_posts, generate_search_query, rank_posts) with clear, descriptive verbs that align with their actions. No deviations or mixed conventions are present.

    Tool Count4/5

    Three tools is a minimal but reasonable count for this server's purpose of finding and ranking slander content. It covers the core workflow (query generation, fetching, ranking) without being overly sparse, though a few additional tools (e.g., for filtering or exporting) could enhance completeness.

    Completeness4/5

    The tool set covers the essential steps for slander discovery: generating queries, fetching posts, and ranking them. Minor gaps exist, such as lacking tools for saving results or refining searches, but agents can work around these with the provided tools to achieve the server's goal.

    Maintenance

    ActivityInactive
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • F
      license
      Not graded
      quality
      Not graded
      maintenance
      An MCP server that analyzes your unique Twitter voice to generate, manage, and post AI-powered tweets and quote tweet drafts. It supports multiple AI providers and provides tools for draft management, voice profiling, and automated content creation from images.
      -
    • A
      license
      A
      quality
      Not graded
      maintenance
      An MCP server that integrates X (Twitter) API access with Grok-powered intelligence for real-time social media analysis and account management. It provides tools for reading and writing tweets, managing direct messages, and generating AI-powered topic summaries or daily briefings.
      23
      MIT
    • A
      license
      Not graded
      quality
      D
      maintenance
      An MCP server for interacting with the Twitter/X API v2, enabling AI assistants to retrieve tweets, post content, reply, quote, and more programmatically.
      2,203 npm
      13
      MIT