Twitter MCP Server For Claude

🚀 Building a Twitter Trends Analysis MCP Server for Claude

This tutorial will guide you through creating a Model Context Protocol (MCP) server that connects real-time Twitter trending topics with Claude's analysis capabilities. The server will fetch real-time Twitter trends and use Claude for business opportunity analysis.

🚀 Quick Start

Prerequisites

• Python 3.8 or higher
• Claude Desktop installed
• A Twitter developer account with API access
• Basic knowledge of Python

Step 1: Set Up the Environment

1. Create a new project directory:

mkdir twitter-trends-mcp
cd twitter-trends-mcp

2. Set up a virtual environment:

python -m venv .venv
.venv\Scripts\activate  # On Windows

3. Install the required packages:

pip install tweepy mcp python-dotenv hatchling

Step 2: Project Structure

Create the following directory structure:

twitter-trends-mcp/
├── pyproject.toml
├── twitter_server_run.py
├── src/
│   └── twitter_trends_mcp/
│       ├── __init__.py
│       └── server.py

Step 3: Configuration Files

1. Create pyproject.toml in the root directory:

[build-system]
requires = ["hatchling"]
build-backend = "hatchling.build"

[project]
name = "twitter-trends-mcp"
version = "0.1.0"
description = "Twitter Trends MCP Server"
requires-python = ">=3.8"
dependencies = [
    "tweepy",
    "mcp",
    "python-dotenv",
    "hatchling"
]

[project.urls]
Homepage = "https://github.com/yourusername/twitter-trends-mcp"

[project.scripts]
console_scripts = [
    "twitter-trends-mcp=twitter_trends_mcp.server:main"
]

2. Create src/twitter_trends_mcp/server.py in the project root directory:

import tweepy
from tweepy import OAuthHandler
import json
import logging

# Configure logging
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    filename='twitter_server.log'
)
logger = logging.getLogger(__name__)

class TwitterTrendServer:
    def __init__(self, config_path):
        self.config = self.load_config(config_path)
        self.authenticated_api = None

    def load_config(self, config_path):
        with open(config_path, 'r') as f:
            return json.load(f)

    def authenticate_twitter_api(self):
        try:
            auth = OAuthHandler(
                self.config['twitter']['api_key'],
                self.config['twitter']['api_secret']
            )
            api = tweepy.API(auth)
            logger.info("Twitter API has been successfully authenticated")
            return api
        except Exception as e:
            logger.error(f"Twitter API authentication failed: {str(e)}")
            raise

    def get_trending_topics(self, woe_id=1):
        try:
            if self.authenticated_api is None:
                self.authenticate_twitter_api()
            trends = self.authenticated_api.trends_place(woe_id)
            return [trend['name'] for trend in trends[0]['trends']]
        except Exception as e:
            logger.error(f"Failed to fetch trends: {str(e)}")
            return []

    def run_server(self):
        while True:
            try:
                # Example: Fetch and print real-time trends
                trends = self.get_trending_topics()
                if trends:
                    logger.info("Current Twitter trending topics:")
                    for trend in trends:
                        logger.info(f"- {trend}")
                else:
                    logger.warning("Failed to fetch any trends. Please check the log file for more information.")
            except KeyboardInterrupt:
                logger.info("Server has been stopped.")
                break
            except Exception as e:
                logger.error(f"An error occurred: {str(e)}")
                continue

if __name__ == "__main__":
    import sys
    if len(sys.argv) < 2:
        print("Usage: python server.py <config file path>")
        sys.exit(1)
    config_path = sys.argv[1]
    server = TwitterTrendServer(config_path)
    server.run_server()

3. Create src/twitter_trends_mcp/__init__.py in the project root directory:

from .server import TwitterTrendServer

__version__ = "0.1.0"

4. Create the configuration file twitter_config.json in the project root directory:

{
    "twitter": {
        "api_key": "your_api_key",
        "api_secret": "your_api_secret"
    },
    "logging": {
        "level": "INFO",
        "file": "twitter_server.log"
    }
}

Step 4: Configure the Server in Claude Desktop

1. Open Claude Desktop.

2. Click on the plugin icon (usually shown as a plug symbol).

3. Select "Add MCP Server" or the corresponding option to configure a new server instance.

4. Fill in the following information:

   • Name: twitter-trends
   • Command: C:\\Users\\YOUR_USERNAME\\twitter-trends-mcp\\.venv\\Scripts\\python.exe
   • Arguments: C:\\Users\\YOUR_USERNAME\\twitter-trends-mcp\\server.py C:\\Users\\YOUR_USERNAME\\twitter-trends-mcp\\twitter_config.json
   • Environment Variables:
     • PYTHONPATH: C:\\Users\\YOUR_USERNAME\\twitter-trends-mcp\\src
     • PYTHONUNBUFFERED: 1
   • Working Directory: C:\\Users\\YOUR_USERNAME\\twitter-trends-mcp

5. Ensure all paths are correct and save the configuration.

Step 5: Run and Test

1. Install the package in the project root directory:

pip install -e .

2. Start the server:

python server.py twitter_config.json

3. In Claude Desktop:

   • Click on the plugin icon.
   • Find the "twitter-trends" instance.
   • Try entering: Analyze current Twitter trends for SaaS opportunities

4. Monitor the log file:

Get-Content twitter_server.log # In Windows PowerShell
# Or use tail -f twitter_server.log in Linux/MacOS

✨ Features

1. Data Storage

You can store the fetched trend data in a database for further analysis.

Steps:

• Use a database such as SQLite, MySQL, or PostgreSQL.
• Modify the get_trending_topics method in server.py to record data.
• Add a regular backup mechanism to prevent data loss.

2. Data Visualization

Integrate visualization tools (such as Plotly or Matplotlib) to display trend changes in real-time.

Steps:

• Add plotting functionality in server.py.
• Generate charts regularly and save them as image files, or display them through a web interface.

3. Automated Analysis

Use natural language processing libraries (such as spaCy or nltk) to perform sentiment analysis or other types of analysis on trend text.

Steps:

• Import the necessary NLP libraries.
• Apply the analysis model to the fetched trend data.
• Record and visualize the analysis results.

4. Scalability and Performance Optimization

If you need to handle a large amount of data, consider the following optimization measures:

• Asynchronous Requests: Use asynchronous libraries like aiohttp and tweepy to improve data fetching speed.
• Distributed Computing: Distribute tasks across multiple nodes to enhance processing capabilities.
• Queue System: Use a queue system such as RabbitMQ or Redis to manage task queues and ensure system scalability.

🔧 Technical Details

Error Troubleshooting and Debugging

1. Authentication Issues

If Twitter API authentication fails:

• Check if the api_key and api_secret are correct.
• Ensure that your developer account and application permissions allow access to real-time trend data.
• Check the Twitter Developer Console for the latest API keys.

2. Network Issues

If you cannot connect to the Twitter API:

• Check your network connection.
• Use a proxy server if necessary.
• Check if your IP has been blocked.

3. Log Analysis

Carefully review the error information in the twitter_server.log file to determine the specific cause and location of the error.

4. Configuration Issues

Ensure that all paths and configuration parameters are correct. Especially in a Windows environment, you may need to adjust the path separators to backslashes or use raw strings.

Security Considerations

• API Key Security: Do not store API keys in plain text in the version control system. You can use environment variables or encrypted configuration files to manage sensitive information.
• Log Monitoring: Regularly review the log file to prevent potential security incidents such as unauthorized access.
• Regularly Update Dependencies: Keep the project's third-party libraries up-to-date to avoid known security vulnerabilities.

📚 Documentation

References and Further Reading

• Twitter API Official Documentation
• Tweepy Library Documentation
• Python Logging Library Documentation
• [MCP Plugin Development Guide (if applicable)]
• [Best Practices for Real-Time Data Analysis]

📄 License

No license information provided in the original document.

💻 Usage Examples

Basic Usage

import tweepy
from tweepy import OAuthHandler
import json
import logging

# Configure logging
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(levelname)s - %(message)s',
    handlers=[
        logging.FileHandler('twitter_server.log'),
        logging.StreamHandler()
    ]
)

logger = logging.getLogger(__name__)

class TwitterTrendMonitor:
    def __init__(self, config_file):
        self.config = self._load_config(config_file)
        self.authenticated = False

    def _load_config(self, config_file):
        with open(config_file) as f:
            return json.load(f)

    def authenticate(self):
        try:
            auth = OAuthHandler(
                self.config['twitter']['api_key'],
                self.config['twitter']['api_secret']
            )
            self.authenticated = True
            logger.info("Successfully authenticated with Twitter API.")
        except Exception as e:
            logger.error(f"Authentication failed: {e}")
            raise

    def get_trends(self):
        if not self.authenticated:
            logger.error("Not authenticated. Cannot fetch trends.")
            return []

        try:
            # Assume you already have an API instance api
            api = self._get_api_instance()
            trends = api.trends_place(id=1)  # Fetch trends in the US
            return [trend.name for trend in trends[0]['trends']]
        except Exception as e:
            logger.error(f"Failed to fetch trends: {e}")
            return []

    def _get_api_instance(self):
        # Implement the method to get the API instance, which may need to handle OAuth tokens, etc.
        pass

def main():
    monitor = TwitterTrendMonitor('twitter_config.json')
    try:
        monitor.authenticate()
        trends = monitor.get_trends()
        logger.info(f"Current trending topics: {trends}")
    except Exception as e:
        logger.error(f"Main execution failed: {e}")

if __name__ == "__main__":
    main()

Advanced Usage

The advanced usage mainly involves the extension functions described in the "Features" section, such as data storage, visualization, automated analysis, etc. You can refer to the relevant steps in the "Features" section to modify the code.