Skip to main content
Glama
cjkcr

X(Twitter) MCP Server

by cjkcr
OverviewSchemaRelated ServersScoreDiscussions
Python
Remote

X(Twitter) MCP Server

English | 中文

An MCP server to create, manage and publish X/Twitter posts directly through Claude code and Gemini CLI chat.

Note: This project is modified from vidhupv/x-mcp, with added reply functionality for tweets.

Features

🔐 Dual Authentication Support

  • ✅ OAuth 1.0a: For write operations (posting tweets, retweeting, etc.)

  • ✅ OAuth 2.0: For read operations (getting tweets, searching, etc.)

  • ✅ Automatic Client Selection: System automatically chooses the best authentication method

  • ✅ Smart Fallback: Automatically falls back to OAuth 1.0a when OAuth 2.0 is unavailable

📝 Tweet Management

  • ✅ Create draft tweets

  • ✅ Create draft tweet threads

  • ✅ Create draft replies to existing tweets

  • ✅ List all drafts

  • ✅ Publish drafts (tweets, threads, and replies)

  • ✅ Reply to tweets directly (without creating drafts)

  • ✅ Retweet existing tweets

  • ✅ Quote tweet with comments

  • ✅ Create draft quote tweets

  • ✅ Delete drafts

  • ✅ Auto-delete failed drafts (configurable)

  • ✅ Draft preservation on publish failure (configurable)

⏰ Scheduled Tweets (NEW!)

  • ✅ Schedule single tweets - Publish tweets at specific times

  • ✅ Schedule tweet threads - Publish complete threads at specific times

  • ✅ Recurring tweets - Publish tweets at regular intervals

  • ✅ Flexible time formats - Support absolute time (2024-01-15T14:30:00) and relative time (+10m, +2h, +1d)

  • ✅ Background scheduler - Automatic execution without manual intervention

  • ✅ Schedule management - View, cancel, and manage all scheduled tweets

  • ✅ Smart intervals - Perfect for regular content publishing and campaigns

📷 Media Support

  • ✅ Upload media files (images, videos, GIFs)

  • ✅ Create tweets with media attachments

  • ✅ Add alt text for accessibility

  • ✅ Get media file information

📖 Tweet Retrieval (Enhanced)

  • ✅ Get tweet content and information (with dual authentication support)

  • ✅ Search recent tweets (improved error handling)

  • ✅ Batch retrieve multiple tweets (more stable connections)

  • ✅ Detailed error diagnostics and suggestions

  • ✅ API connection testing tools

Related MCP server: Typefully MCP Server

System Requirements

Before starting the installation, please ensure your system meets the following requirements:

Required Software

  • Python 3.8+ - Project runtime environment

  • Node.js 16+ - For installing Gemini CLI (if using Gemini)

  • UV - Python package manager (recommended) or pip

  • Git - For cloning the project

Installing Prerequisites

macOS Users:

# Install Homebrew (if you don't have it)
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

# Install required software
brew install python node git uv

Windows Users:

# Using Chocolatey (recommended)
choco install python nodejs git

# Then install UV
pip install uv

Linux Users:

# Ubuntu/Debian
sudo apt update
sudo apt install python3 python3-pip nodejs npm git
pip3 install uv

# CentOS/RHEL
sudo yum install python3 python3-pip nodejs npm git
pip3 install uv

Quick Setup

Installing via Smithery

To install X(Twitter) MCP Server for Claude code automatically via Smithery:

npx -y @smithery/cli install x-mcp --client claude

Manual Installation for Claude code

1. Project Setup

Clone project and set up environment:

# Clone the repository
git clone https://github.com/yourusername/x-mcp.git
cd x-mcp

# Install UV (Python package manager)
# macOS users (recommended):
brew install uv

# Or use pip:
pip install uv

Install dependencies (choose one method):

Method 1: Automatic environment creation and installation (Recommended)

# One step: create virtual environment and install dependencies
uv sync

# Activate virtual environment (if manual operation needed)
# macOS/Linux:
source .venv/bin/activate
# Windows:
# .venv\Scripts\activate

Method 2: Manual environment creation and installation

# Manually create virtual environment
uv venv

# Activate virtual environment
# macOS/Linux:
source .venv/bin/activate
# Windows:
# .venv\Scripts\activate

# Install dependencies from pyproject.toml
uv pip sync pyproject.toml

2. Configure Claude Desktop

Create claude_desktop_config.json:

  • For MacOS: Open directory ~/Library/Application Support/Claude/ and create the file inside it

  • For Windows: Open directory %APPDATA%/Claude/ and create the file inside it

Add this configuration to claude_desktop_config.json:

Basic Configuration (OAuth 1.0a Only)

{
  "mcpServers": {
    "x_mcp": {
      "command": "uv",
      "args": [
        "--directory",
        "/path/to/x-mcp",
        "run",
        "x-mcp"
      ],
      "env": {
        "TWITTER_API_KEY": "your_api_key",
        "TWITTER_API_SECRET": "your_api_secret",
        "TWITTER_ACCESS_TOKEN": "your_access_token",
        "TWITTER_ACCESS_TOKEN_SECRET": "your_access_token_secret"
      }
    }
  }
}

Recommended Configuration (OAuth 1.0a + OAuth 2.0 Dual Authentication)

{
  "mcpServers": {
    "x_mcp": {
      "command": "uv",
      "args": [
        "--directory",
        "/path/to/x-mcp",
        "run",
        "x-mcp"
      ],
      "env": {
        "TWITTER_API_KEY": "your_api_key",
        "TWITTER_API_SECRET": "your_api_secret",
        "TWITTER_ACCESS_TOKEN": "your_access_token",
        "TWITTER_ACCESS_TOKEN_SECRET": "your_access_token_secret",
        "TWITTER_BEARER_TOKEN": "your_bearer_token"
      }
    }
  }
}

💡 Recommended to use dual authentication configuration: Adding TWITTER_BEARER_TOKEN can significantly improve the stability and success rate of tweet retrieval functions.

3. Get X/Twitter API Credentials

  1. Visit X API Developer Portal:

  2. Create Project and App:

    • Create a new project

    • Create an app within the project

  3. Configure App Permissions:

    • In User Authentication Settings: Set to Read and Write permissions

    • App type: Select Web App

    • Callback URL: Set to http://localhost/

    • Website URL: Set to http://example.com/

  4. Generate API Keys and Tokens:

    • From the "Keys and Tokens" section, generate:

      • API Key (Consumer Key)

      • API Secret (Consumer Secret)

      • Access Token

      • Access Token Secret

      • Bearer Token (recommended for dual authentication)

4. Update Configuration and Start

Update the config file:

  • Replace /path/to/x-mcp with your actual project path (e.g., /Users/yourname/x-mcp)

  • Replace all your_* placeholders with your actual API credentials

Quit Claude completely and reopen it

5. Verify Installation

Test the connection in Claude:

test api connection

If everything is configured correctly, you should see successful connection test results.

Configuration for Gemini CLI

If you want to use this MCP server with Gemini CLI instead of Claude code:

1. Project Setup

Clone project and set up environment:

# Clone the repository
git clone https://github.com/yourusername/x-mcp.git
cd x-mcp

# Install UV (Python package manager)
# macOS users:
brew install uv

# Or use pip:
pip install uv

Install dependencies (choose one method):

Method 1: Automatic environment creation and installation (Recommended)

# One step: create virtual environment and install dependencies
uv sync

# Activate virtual environment (if manual operation needed)
# macOS/Linux:
source .venv/bin/activate
# Windows:
# .venv\Scripts\activate

Method 2: Manual environment creation and installation

# Manually create virtual environment
uv venv

# Activate virtual environment
# macOS/Linux:
source .venv/bin/activate
# Windows:
# .venv\Scripts\activate

# Install dependencies from pyproject.toml
uv pip sync pyproject.toml

2. Install and Configure Gemini CLI

Install Gemini CLI:

npm install -g @google/gemini-cli

Create or update your MCP configuration file:

# Create configuration directory (if it doesn't exist)
mkdir -p ~/.gemini

# Create configuration file
touch ~/.gemini/settings.json

Edit configuration file ~/.gemini/settings.json:

Basic Configuration (OAuth 1.0a Only)

{
  "mcpServers": {
    "x_mcp": {
      "command": "uv",
      "args": [
        "--directory",
        "/path/to/x-mcp",
        "run",
        "x-mcp"
      ],
      "env": {
        "TWITTER_API_KEY": "your_api_key",
        "TWITTER_API_SECRET": "your_api_secret",
        "TWITTER_ACCESS_TOKEN": "your_access_token",
        "TWITTER_ACCESS_TOKEN_SECRET": "your_access_token_secret"
      }
    }
  }
}

Recommended Configuration (OAuth 1.0a + OAuth 2.0 Dual Authentication)

{
  "mcpServers": {
    "x_mcp": {
      "command": "uv",
      "args": [
        "--directory",
        "/path/to/x-mcp",
        "run",
        "x-mcp"
      ],
      "env": {
        "TWITTER_API_KEY": "your_api_key",
        "TWITTER_API_SECRET": "your_api_secret",
        "TWITTER_ACCESS_TOKEN": "your_access_token",
        "TWITTER_ACCESS_TOKEN_SECRET": "your_access_token_secret",
        "TWITTER_BEARER_TOKEN": "your_bearer_token"
      }
    }
  }
}

3. Get X/Twitter API Credentials

  1. Visit X API Developer Portal:

  2. Create Project and App:

    • Create a new project

    • Create an app within the project

  3. Configure App Permissions:

    • In User Authentication Settings: Set to Read and Write permissions

    • App type: Select Web App

    • Callback URL: Set to http://localhost/

    • Website URL: Set to http://example.com/

  4. Generate API Keys and Tokens:

    • From the "Keys and Tokens" section, generate:

      • API Key (Consumer Key)

      • API Secret (Consumer Secret)

      • Access Token

      • Access Token Secret

      • Bearer Token (recommended for dual authentication)

4. Update Configuration and Start

Update the config file:

  • Replace /path/to/x-mcp with your actual project path (e.g., /Users/yourname/x-mcp)

  • Replace all your_* placeholders with your actual API credentials

Start Gemini CLI:

# Start Gemini CLI with MCP support
gemini-cli

# Or if you need to specify config file path:
gemini-cli --config ~/.gemini/settings.json

5. Verify Installation

Test the connection in Gemini CLI:

test api connection

If everything is configured correctly, you should see successful connection test results.

Advanced Configuration

Auto-Delete Failed Drafts

When tweet publishing fails, you can choose whether to automatically delete drafts:

  • Enable auto-delete (default): Automatically delete drafts when publishing fails to avoid accumulating invalid drafts

  • Disable auto-delete: Preserve drafts when publishing fails, allowing manual retry or modification

Configuration Methods

  1. Via Environment Variable: Add "AUTO_DELETE_FAILED_DRAFTS": "true" or "false" in your configuration file

  2. Via Commands: Use "Enable auto-delete failed drafts" or "Disable auto-delete failed drafts"

  3. Check Status: Use "Check current auto-delete configuration"

Usage Examples

Works with both Claude code and Gemini CLI:

Basic Tweet Operations

  • "Tweet 'Just learned how to tweet through AI - mind blown! 🤖✨'"

  • "Create a thread about the history of pizza"

  • "Show me my draft tweets"

  • "Publish this draft!"

  • "Delete that draft"

  • "Reply to tweet 1234567890 with 'Great point! Thanks for sharing.'"

  • "Create a draft reply to tweet 1234567890 saying 'I completely agree with this perspective.'"

  • "Retweet tweet 1234567890"

  • "Quote tweet 1234567890 with comment 'This is exactly what I was thinking!'"

  • "Create a draft quote tweet for 1234567890 with comment 'Amazing insight here'"

Media Operations

  • "Upload image /path/to/image.jpg with alt text 'Beautiful sunset over the mountains'"

  • "Create tweet with media 'Check out this amazing photo!' using media IDs 123456789"

  • "Create draft tweet with media 'My latest project' and attach /path/to/video.mp4"

Scheduled Tweets (NEW!)

  • "Schedule a tweet 'Good morning everyone! ☀️' for tomorrow at 9 AM"

  • "Create a scheduled thread about productivity tips for next Monday at 2 PM"

  • "Set up recurring tweets every 10 minutes starting in 5 minutes: ['Tip 1: Stay hydrated', 'Tip 2: Take breaks', 'Tip 3: Exercise regularly']"

  • "Schedule tweet 'Weekend vibes! 🎉' for +2h"

  • "Create recurring tweets every 30 minutes for the next 3 hours with motivational quotes"

  • "List all my scheduled tweets"

  • "Cancel scheduled tweet scheduled_tweet_1234567890.json"

  • "Start the tweet scheduler"

  • "Stop the tweet scheduler"

Configuration & Management

  • "Enable auto-delete failed drafts"

  • "Disable auto-delete failed drafts"

  • "Check current auto-delete configuration"

Tweet Retrieval

  • "Get tweet 1234567890 content and information"

  • "Search for tweets containing 'AI OR artificial intelligence' from the last 7 days"

  • "Get information for tweets 123456789, 987654321, 555666777"

Troubleshooting

Environment Setup Issues

UV not found or installation failed:

# Check if UV is properly installed
which uv
uv --version

# If not found, reinstall
pip uninstall uv
brew install uv  # macOS
# or
pip install uv   # other systems

Virtual environment issues:

# Delete existing virtual environment
rm -rf .venv

# Recreate (choose one method):

# Method 1: Automatic creation and installation (recommended)
uv sync

# Method 2: Manual creation and installation
uv venv
source .venv/bin/activate  # macOS/Linux or .venv\Scripts\activate (Windows)
uv pip sync pyproject.toml

Python version incompatibility:

# Check Python version (requires 3.8+)
python --version
python3 --version

# If version is too old, upgrade Python
brew install python@3.11  # macOS
# or use your system package manager to upgrade

Basic Issues

If not working:

  • Make sure UV is installed globally (if not, uninstall with pip uninstall uv and reinstall with brew install uv)

  • Or find UV path with which uv and replace "command": "uv" with the full path

  • Verify all X/Twitter credentials are correct

  • Check if the x-mcp path in config matches your actual repository location

🔧 API Connection Testing

Quick Diagnosis:

test api connection

Running this command in Claude will:

  • Test OAuth 1.0a and OAuth 2.0 connections

  • Check API permissions and limitations

  • Provide detailed diagnostic information and suggestions

Run Test Script:

cd /path/to/x-mcp
python test_tweet_functions.py

🚨 401 Unauthorized Error Fix

Problem Symptoms:

  • Getting "401 Unauthorized" error when posting tweets

  • Can post tweets but cannot retrieve tweets

Solutions:

  1. Add Bearer Token (Recommended):

    "env": {
  "TWITTER_API_KEY": "your_api_key",
  "TWITTER_API_SECRET": "your_api_secret",
  "TWITTER_ACCESS_TOKEN": "your_access_token",
  "TWITTER_ACCESS_TOKEN_SECRET": "your_access_token_secret",
  "TWITTER_BEARER_TOKEN": "your_bearer_token"
}

  2. Regenerate API Credentials:

  3. Check Project Settings:

    • User authentication settings: Read and write permissions

    • App type: Web App

    • Callback URL: http://localhost/

    • Website URL: http://example.com/

📖 Tweet Retrieval Issues

Dual Authentication Benefits:

  • OAuth 2.0 for read operations (more stable)

  • OAuth 1.0a for write operations (required)

  • Automatic fallback handling

Common Errors and Solutions:

Error Code

Cause

Solution

401

Authentication failed

Check API credentials, regenerate tokens

403

Insufficient permissions

Upgrade API plan or check permission settings

404

Tweet not found

Verify tweet ID, check if tweet is public

429

Rate limit exceeded

Wait 15 minutes or upgrade API plan

API Plan Limitations:

  • Free Users: Basic functionality with limitations

  • Basic ($100/month): Full read functionality

  • Pro ($5000/month): Advanced features and higher limits

🔍 Detailed Diagnostic Steps

  1. Check Authentication Status:

    test api connection

  2. Verify Configuration:

    • Confirm all environment variables are set

    • Check paths are correct

    • Validate API key formats

  3. Test Specific Functions:

    search for tweets containing "hello"
get tweet 1234567890 content

  4. Review Detailed Logs:

    • Check Claude Desktop console

    • Review MCP server logs

    • Note specific error messages

Credits

This project is based on the excellent work by Vidhu Panhavoor Vasudevan in the original x-mcp repository.

What's New in This Fork

  • 🆕 Scheduled Tweets System - Schedule single tweets, threads, and recurring tweets with flexible timing

  • 🆕 OAuth Dual Authentication System - Support for OAuth 1.0a + OAuth 2.0, automatic selection of best authentication method

  • 🆕 401 Error Fix - Resolved authentication issues when retrieving tweets

  • 🆕 Smart Client Selection - Read operations prefer OAuth 2.0, write operations use OAuth 1.0a

  • 🆕 Enhanced Error Handling - Detailed error diagnostics and English error messages

  • 🆕 API Connection Testing Tool - Built-in connection testing and diagnostic functionality

  • ✅ Reply to tweets functionality - Create draft replies and reply directly to existing tweets

  • ✅ Retweet functionality - Simple retweets and quote tweets with comments

  • ✅ Media functionality - Upload images, videos, GIFs with alt text support

  • ✅ Tweet retrieval functionality - Get tweet content, search tweets, batch retrieve multiple tweets

  • ✅ Enhanced draft management - Improved draft preservation on publish failure, support for all draft types

Special thanks to the original author for creating the foundation of this MCP server!

Detailed Documentation

For more detailed functionality descriptions and usage guides, please refer to:

Available Tools

10 tools
create_draft_quote_tweetC

Create a draft quote tweet with comment

ParametersJSON Schema
NameRequiredDescriptionDefault
commentYesYour comment on the quoted tweet
tweet_idYesThe ID of the tweet to quote

TDQS

C2.9/5.0
Behavior2/5

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool creates a draft, implying a non-destructive, preparatory action, but doesn't clarify if it's read-only, requires specific permissions, or has side effects like rate limits. This leaves key behavioral traits unspecified.

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

Conciseness5/5

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

The description is a single, efficient sentence that directly states the tool's purpose without unnecessary words. It's front-loaded and appropriately sized, making it easy to parse quickly.

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 the lack of annotations and output schema, the description is incomplete. It doesn't address behavioral aspects like authentication needs, draft lifecycle, or error handling, which are crucial for a tool that creates drafts. This leaves significant gaps in understanding how to use the tool effectively.

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

Parameters3/5

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

The schema description coverage is 100%, so the input schema already documents both parameters ('comment' and 'tweet_id') adequately. The description adds no additional meaning beyond what the schema provides, such as format examples or constraints, resulting in a baseline score.

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

Purpose4/5

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

The description clearly states the action ('Create a draft quote tweet') and resource ('quote tweet with comment'), making the purpose evident. However, it doesn't explicitly differentiate from sibling tools like 'quote_tweet' or 'create_draft_reply', which could cause confusion about when to use each.

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?

No guidance is provided on when to use this tool versus alternatives like 'quote_tweet' or 'create_draft_reply'. The description lacks context about prerequisites, such as whether authentication is needed or if the draft must be published separately, leaving the agent without usage direction.

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

create_draft_replyC

Create a draft reply to an existing tweet

ParametersJSON Schema
NameRequiredDescriptionDefault
contentYesThe content of the reply tweet
reply_to_tweet_idYesThe ID of the tweet to reply to

TDQS

C2.9/5.0
Behavior2/5

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool creates a draft reply, implying a write operation that doesn't publish immediately, but fails to mention critical details: whether it requires specific permissions, if drafts are saved locally or on a server, what happens on success/failure, or any rate limits. For a mutation tool with zero annotation coverage, this is a significant gap in transparency.

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

Conciseness5/5

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

The description is a single, efficient sentence that front-loads the core purpose without unnecessary words. Every part of the sentence earns its place by specifying the action, resource, and context. There is no redundancy or fluff, making it highly concise and well-structured for quick understanding.

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 the complexity of a mutation tool with no annotations and no output schema, the description is incomplete. It lacks information on behavioral traits (e.g., draft storage, error handling), usage context relative to siblings, and output details. While the schema covers parameters well, the overall context for safe and effective tool invocation is insufficient, especially compared to sibling tools that might offer similar or overlapping functionality.

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

Parameters3/5

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

The schema description coverage is 100%, with both parameters ('content' and 'reply_to_tweet_id') clearly documented in the schema. The description adds no additional parameter semantics beyond what the schema provides, such as content length limits or tweet ID format requirements. Given the high schema coverage, the baseline score of 3 is appropriate, as the description doesn't compensate but also doesn't need to given the schema's completeness.

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

Purpose4/5

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

The description clearly states the action ('Create a draft reply') and the resource ('to an existing tweet'), making the purpose immediately understandable. However, it doesn't explicitly differentiate this from sibling tools like 'reply_to_tweet' or 'create_draft_quote_tweet', which would require more specific language about draft vs. published replies or reply vs. quote functionality.

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 mention when to choose 'create_draft_reply' over 'reply_to_tweet' (which might publish immediately) or 'create_draft_quote_tweet' (which creates a quote tweet draft), nor does it specify prerequisites like authentication or draft limitations. This leaves the agent without context for tool selection.

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

create_draft_threadC

Create a draft tweet thread

ParametersJSON Schema
NameRequiredDescriptionDefault
contentsYesAn array of tweet contents for the thread

TDQS

C2.9/5.0
Behavior2/5

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the action ('Create a draft tweet thread') but does not explain what 'draft' entails (e.g., saved locally vs. on a server), permissions required, or any side effects like rate limits or data persistence, leaving significant gaps.

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

Conciseness5/5

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

The description is a single, direct sentence with no wasted words, clearly stating the tool's purpose. It is appropriately sized and front-loaded, making it efficient and easy to understand at a glance.

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 the lack of annotations and output schema, the description is incomplete for a tool that creates a draft. It does not cover what a 'draft' means in this context, how it interacts with other tools like 'publish_draft', or what the expected outcome is, leaving the agent with insufficient information for effective use.

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

Parameters3/5

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

The schema description coverage is 100%, with the 'contents' parameter well-documented in the schema as an array of tweet contents. The description does not add any additional meaning or context beyond this, such as formatting rules or constraints, so it meets the baseline for adequate but not enhanced parameter explanation.

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

Purpose4/5

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

The description clearly states the verb ('Create') and resource ('draft tweet thread'), making the purpose evident. However, it does not explicitly differentiate from siblings like 'create_draft_tweet' or 'create_draft_reply', which might involve similar actions but for different tweet types, leaving some ambiguity.

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?

No guidance is provided on when to use this tool versus alternatives such as 'create_draft_tweet' or 'create_draft_reply'. The description lacks context about prerequisites, exclusions, or specific scenarios for creating a draft thread, offering minimal usage direction.

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

create_draft_tweetC

Create a draft tweet

ParametersJSON Schema
NameRequiredDescriptionDefault
contentYesThe content of the tweet

TDQS

C2.7/5.0
Behavior2/5

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

With no annotations provided, the description carries full burden for behavioral disclosure. 'Create a draft tweet' implies a write operation but doesn't specify permissions needed, whether drafts are saved locally or to a service, what happens if content exceeds length limits, or any other behavioral aspects. It's minimally informative about the tool's behavior.

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

Conciseness5/5

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

The description is extremely concise with just three words that directly state the tool's purpose. There's zero waste or unnecessary elaboration, making it maximally efficient while still communicating the core function.

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?

For a write operation tool with no annotations and no output schema, the description is insufficiently complete. It doesn't explain what constitutes a successful creation, whether there are character limits or content restrictions, how the draft is stored or accessed, or what the tool returns. The context demands more information than provided.

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

Parameters3/5

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

The schema description coverage is 100% with one parameter 'content' fully documented as 'The content of the tweet'. The description adds no additional parameter information beyond what the schema provides, so it meets the baseline of 3 for adequate but not additive parameter documentation.

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

Purpose3/5

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

The description 'Create a draft tweet' clearly states the action (create) and resource (draft tweet), but it doesn't differentiate from sibling tools like create_draft_quote_tweet, create_draft_reply, or create_draft_thread. It's a basic statement of purpose without specifying what makes this tool distinct from other draft creation tools.

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. With multiple draft creation tools available (create_draft_quote_tweet, create_draft_reply, create_draft_thread), there's no indication of when this basic draft creation is appropriate versus those specialized alternatives.

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

delete_draftC

Delete a draft tweet or thread

ParametersJSON Schema
NameRequiredDescriptionDefault
draft_idYesID of the draft to delete

TDQS

C2.9/5.0
Behavior2/5

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the destructive action ('Delete') but lacks critical details: whether deletion is permanent or reversible, if it requires specific permissions, what happens on success/failure, or any rate limits. This is inadequate for a mutation tool with zero annotation coverage.

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

Conciseness5/5

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

The description is a single, efficient sentence that directly states the tool's purpose without any wasted words. It's front-loaded with the core action and resource, making it highly concise and well-structured for quick understanding.

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 the tool's destructive nature, lack of annotations, and no output schema, the description is incomplete. It doesn't cover behavioral aspects like permanence, permissions, or response format, nor does it relate to sibling tools. For a delete operation with such sparse structured data, more context is needed.

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

Parameters3/5

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

The schema description coverage is 100%, with the single parameter 'draft_id' clearly documented in the schema. The description adds no additional parameter semantics beyond implying the parameter identifies the draft to delete, so it meets the baseline for high schema coverage without compensating value.

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

Purpose4/5

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

The description clearly states the action ('Delete') and the resource ('a draft tweet or thread'), making the purpose immediately understandable. However, it doesn't differentiate this tool from potential sibling operations like 'publish_draft' or 'list_drafts' beyond the obvious verb difference, which keeps it from a perfect score.

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 mention prerequisites (e.g., needing an existing draft), exclusions (e.g., not for published tweets), or comparisons to siblings like 'publish_draft' or 'list_drafts', leaving usage context entirely implicit.

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

list_draftsB

List all draft tweets and threads

ParametersJSON Schema
NameRequiredDescriptionDefault

No parameters

TDQS

B3.1/5.0
Behavior2/5

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

With no annotations provided, the description carries full burden but only states the basic action. It doesn't disclose behavioral traits such as whether listing is paginated, if it requires authentication, what format the output returns, or any rate limits. This leaves significant gaps in understanding the tool's behavior.

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

Conciseness5/5

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

The description is a single, efficient sentence with zero waste. It's front-loaded with the core purpose and avoids any redundant or verbose phrasing, making it highly concise and well-structured.

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 the lack of annotations and output schema, the description is incomplete. It doesn't address what the output looks like (e.g., list format, fields included), behavioral aspects like pagination, or error conditions. For a tool that likely returns data, this leaves the agent under-informed.

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 0 parameters with 100% schema description coverage, so no parameter documentation is needed. The description appropriately doesn't mention parameters, earning a baseline score of 4 for not adding unnecessary information.

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

Purpose4/5

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

The description clearly states the action ('List') and target resources ('all draft tweets and threads'), providing a specific verb+resource combination. However, it doesn't differentiate from sibling tools like 'create_draft_tweet' or 'delete_draft' beyond the listing action, which prevents a perfect score.

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 like 'publish_draft' or 'delete_draft'. It lacks context about prerequisites, timing, or exclusions, leaving the agent with minimal usage direction.

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

publish_draftC

Publish a draft tweet or thread

ParametersJSON Schema
NameRequiredDescriptionDefault
draft_idYesID of the draft to publish

TDQS

C2.9/5.0
Behavior2/5

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the action ('Publish') which implies a write/mutation operation, but doesn't disclose any behavioral traits such as whether this is destructive (e.g., does publishing remove the draft?), what permissions are required, error conditions, or what happens after publishing. This leaves significant gaps for an agent to understand the tool's behavior.

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

Conciseness5/5

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

The description is extremely concise - a single sentence with zero wasted words. It's front-loaded with the core action and resource, making it immediately clear what the tool does without any unnecessary elaboration.

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 this is a mutation tool (publishing implies writing/changing state) with no annotations and no output schema, the description is incomplete. It doesn't explain what happens after publishing, what gets returned, error scenarios, or how this differs from other publishing tools in the sibling list. For a tool that changes system state, more context is needed.

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

Parameters3/5

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

The schema description coverage is 100%, with the single parameter 'draft_id' clearly documented in the schema. The description doesn't add any additional semantic context about the parameter beyond what's in the schema (e.g., format examples, where to find draft IDs, or validation rules). This meets the baseline of 3 when the schema does the heavy lifting.

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

Purpose4/5

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

The description clearly states the action ('Publish') and the resource ('a draft tweet or thread'), making the purpose immediately understandable. However, it doesn't differentiate this tool from its siblings like 'quote_tweet' or 'reply_to_tweet' which also involve publishing content, leaving some ambiguity about when this specific tool should be used versus those alternatives.

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 like 'quote_tweet' or 'reply_to_tweet'. It doesn't mention prerequisites (e.g., needing an existing draft), exclusions, or contextual factors that would help an agent choose correctly among the publishing-related tools in the sibling list.

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

quote_tweetB

Quote tweet with comment (retweet with your own comment)

ParametersJSON Schema
NameRequiredDescriptionDefault
commentYesYour comment on the quoted tweet
tweet_idYesThe ID of the tweet to quote

TDQS

B3.4/5.0
Behavior2/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. It mentions the action ('quote tweet with comment') but does not disclose critical traits such as whether this is a public post, requires authentication, has rate limits, or what the expected outcome is (e.g., success/failure response). For a mutation tool with zero annotation coverage, this is a significant gap.

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

Conciseness5/5

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

The description is a single, efficient sentence that front-loads the core action ('quote tweet with comment') and includes a clarifying parenthetical. Every word earns its place with no redundancy or unnecessary elaboration.

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 the complexity of a mutation tool (posting to a social platform) with no annotations and no output schema, the description is incomplete. It lacks information on behavioral traits (e.g., authentication needs, side effects) and expected outputs, which are crucial for an agent to use the tool correctly and safely.

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

Parameters3/5

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

Schema description coverage is 100%, with clear parameter descriptions in the schema ('Your comment on the quoted tweet' and 'The ID of the tweet to quote'). The description adds no additional meaning beyond what the schema provides, such as format details or constraints. Baseline 3 is appropriate when the schema does the heavy lifting.

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

Purpose5/5

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

The description clearly states the specific action ('quote tweet with comment') and resource ('tweet'), distinguishing it from siblings like 'retweet' (which lacks a comment) and 'reply_to_tweet' (which is a direct reply rather than a quote). The phrase 'retweet with your own comment' further clarifies the purpose by relating it to a familiar Twitter concept.

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

Usage Guidelines3/5

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

The description implies usage by specifying the action, but it does not explicitly state when to use this tool versus alternatives like 'retweet' (for sharing without comment) or 'reply_to_tweet' (for direct replies). No exclusions or prerequisites are mentioned, leaving the agent to infer context from the tool name and description alone.

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

reply_to_tweetA

Reply to an existing tweet directly (without creating a draft)

ParametersJSON Schema
NameRequiredDescriptionDefault
contentYesThe content of the reply tweet
reply_to_tweet_idYesThe ID of the tweet to reply to

TDQS

A4.2/5.0
Behavior3/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. It indicates this is a write operation ('Reply to') but doesn't disclose behavioral traits like authentication requirements, rate limits, error conditions, or what happens if the tweet ID is invalid. The description adds some context about direct posting but lacks comprehensive behavioral details.

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

Conciseness5/5

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

The description is a single, efficient sentence that front-loads the key information ('Reply to an existing tweet directly') and adds necessary clarification ('without creating a draft'). Every word earns its place with zero waste.

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

Completeness4/5

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

Given the tool's moderate complexity (a write operation with 2 parameters), no annotations, and no output schema, the description is reasonably complete for purpose and usage but lacks behavioral details like error handling or response format. It compensates well for the absence of annotations in differentiating from siblings but could be more comprehensive.

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

Parameters3/5

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

Schema description coverage is 100%, so the schema already fully documents both parameters ('content' and 'reply_to_tweet_id'). The description doesn't add any meaning beyond what the schema provides, such as format examples or constraints. Baseline 3 is appropriate when the schema does all the work.

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

Purpose5/5

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

The description clearly states the specific action ('Reply to an existing tweet') and resource ('tweet'), distinguishing it from siblings like 'create_draft_reply' by specifying 'directly (without creating a draft)'. This provides precise differentiation and avoids ambiguity.

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

Usage Guidelines5/5

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

The description explicitly states when to use this tool ('Reply to an existing tweet directly') and when not to use it ('without creating a draft'), clearly differentiating it from alternatives like 'create_draft_reply' and 'publish_draft'. This provides perfect guidance for tool selection.

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

retweetA

Retweet an existing tweet (simple retweet without comment)

ParametersJSON Schema
NameRequiredDescriptionDefault
tweet_idYesThe ID of the tweet to retweet

TDQS

A3.6/5.0
Behavior2/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. It states the action ('retweet') but doesn't disclose behavioral traits such as authentication requirements, rate limits, whether it's idempotent, what happens on success/failure, or if it requires specific permissions. The description is minimal and lacks crucial operational context.

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

Conciseness5/5

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

The description is a single, efficient sentence with zero waste. It's front-loaded with the core action and includes a clarifying detail ('without comment') that adds value. Every word earns its place, making it highly concise and well-structured.

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 the complexity (a write operation with no annotations and no output schema), the description is incomplete. It lacks details on behavioral aspects (e.g., auth, side effects), response handling, and error conditions. For a mutation tool in a social media context, this leaves significant gaps for an AI agent.

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

Parameters3/5

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

Schema description coverage is 100%, with the parameter 'tweet_id' fully documented in the schema. The description doesn't add any meaning beyond what the schema provides (e.g., no examples, format details, or constraints). Baseline 3 is appropriate since the schema does the heavy lifting.

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

Purpose5/5

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

The description clearly states the specific action ('retweet') and resource ('an existing tweet'), and distinguishes it from siblings by specifying 'simple retweet without comment' (unlike quote_tweet which adds commentary). It uses precise language that directly communicates the tool's function.

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

Usage Guidelines4/5

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

The description provides clear context by specifying 'simple retweet without comment,' which implicitly distinguishes it from quote_tweet (which adds commentary). However, it doesn't explicitly state when to use this versus alternatives like quote_tweet or create_draft_quote_tweet, nor does it mention prerequisites or exclusions.

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

Install Server
RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

TDQS

B3.4/5.0
Disambiguation3/5

The tools have clear distinctions between draft creation (create_draft_tweet, create_draft_reply, create_draft_thread, create_draft_quote_tweet) and direct actions (reply_to_tweet, quote_tweet, retweet), but there is some overlap: create_draft_reply and reply_to_tweet both handle replies, differing only in draft vs. direct, which could cause confusion. Similarly, create_draft_quote_tweet and quote_tweet serve similar purposes with a draft distinction.

Naming Consistency5/5

All tool names follow a consistent snake_case pattern with clear verb_noun structure (e.g., create_draft_tweet, delete_draft, list_drafts). The naming is predictable and uniform across all tools, making it easy for agents to understand and use them without confusion.

Tool Count5/5

With 10 tools, this server is well-scoped for managing tweets and drafts on X (Twitter). The count is appropriate, covering creation, deletion, listing, and publishing of drafts, as well as direct tweet actions, without being overly complex or too sparse for the domain.

Completeness4/5

The tool set provides good coverage for tweet and draft management, including CRUD-like operations (create, list, delete, publish) and direct interactions (reply, quote, retweet). A minor gap exists in updating drafts (e.g., edit_draft), but agents can work around this by deleting and recreating drafts, and the core workflows are well-supported.

Maintenance

ActivityInactive
ResponsivenessNo issues

Resources

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Connectors

Related MCP Servers

  • Twitter MCP Server

    GenAIwithMS
    A
    license
    A
    quality
    A
    maintenance
    Enables seamless interaction with Twitter/X platform through Claude AI, allowing users to post tweets with images, search for tweets, and engage in conversations using natural language commands.
    10
    74
    25
    MIT

  • X (Twitter) MCP

    arnaldo-delisio
    A
    license
    Not graded
    quality
    D
    maintenance
    Enables interaction with X (Twitter) to post tweets, threads, and replies while retrieving tweet metrics and account information. It supports core management tasks like deleting tweets and verifying authentication through the Twitter API.
    MIT

Latest Blog Posts

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/cjkcr/x-mcp'

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