Figma Chunked

🚀 Figma MCP Server with Chunking

A Model Context Protocol (MCP) server for interacting with the Figma API, featuring built-in memory-efficient chunking and pagination for handling large Figma files.

🚀 Quick Start

This MCP server provides a powerful interface to interact with the Figma API and comes with built-in memory management capabilities. It is designed to handle large Figma files efficiently by breaking operations into manageable chunks and implementing pagination if necessary.

✨ Features

• Memory-aware processing with configurable limits
• Chunking for large file data retrieval
• Pagination support for all list operations
• Node type filtering
• Progress tracking
• Configurable chunk size
• Cursor-based resume functionality
• Detailed debug logging
• Comprehensive error handling

📦 Installation

Method 1: Install via the Smithery Platform

1. Visit Smithery.
2. Search for and select the "Figma MCP Server with Chunking" toolkit.
3. Follow the prompts to complete the installation process.

Method 2: Manual Installation (for Advanced Users)

1. Clone this repository to your local development environment:

git clone https://github.com/your-username/figma-mcp-chunked.git

2. Install all dependencies:

npm install

3. Start the server:

node index.js

📚 Documentation

Configuration via Environment Variables

Adjust the server behavior by setting the following environment variables:

• MCP_SERVER_PORT: Specify the port on which the server runs (default is 3000).
• MCP_API_KEY: Specify the key for interacting with the Figma API.
• MCP_DEBUG_MODE: Enable debug mode (optional values are true or false).

Configuration via a Config File

Create a config.json file and specify the following parameters:

{
  "port": 3000,
  "apiKey": "your-api-key",
  "debugMode": true
}

MCP Toolkit

Here are the available MCP tools and their descriptions:

1. get_file_data: Retrieve file data

Parameter requirements:

• fileKey: Required. Specify the file key to retrieve.
• accessToken: Required. Access token for authentication.

Usage example:

curl -X POST http://localhost:3000/mcp/tool/get_file_data \
  -H "Content-Type: application/json" \
  -d '{"fileKey":"your-file-key","accessToken":"your-access-token"}'

2. process_blocks: Process data blocks

Parameter requirements:

• blockSize: Optional. Specify the size of each block (default is 100).
• maxMemoryMB: Optional. Specify the maximum memory usage limit in MB (default is 512).

Memory Management Strategies

Best Practices for Chunking

1. Start with a small chunk size: Begin with processing 50 to 100 nodes per chunk and adjust based on performance.
2. Monitor memory usage: Track memory usage through response metadata.
3. Use node type filtering: Reduce the data load as much as possible.
4. Implement pagination: Use pagination for large datasets.
5. Specify a small depth value: When processing nested structures.

Configurable Options

• pageSize: Number of nodes in each block (default is 100).
• maxMemoryMB: Maximum memory usage limit in MB (default is 512).
• nodeTypes: Filter specific node types.
• depth: Control the traversal depth of nested structures.

Debug Logging

The server includes detailed debug logs:

// Example debug logs
[MCP Debug] Loading configuration from config.json
[MCP Debug] Found access token xxxxxxxx...
[MCP Debug] Request { tool: 'get_file_data', arguments: {...} }
[MCP Debug] Response size is 2.5 MB

Error Handling

The server provides detailed error messages and suggestions:

// Memory limit error
"Response is too large. Try using a smaller depth value or specifying node_id."

// Parameter error
"Missing required parameters: fileKey and accessToken"

// API error
"Figma API error: [Details]"

Troubleshooting

Common Issues

1. Memory errors

   • Reduce the chunk size.
   • Use node type filtering.
   • Implement pagination.
   • Specify a smaller depth value.

2. Performance issues

   • Monitor memory usage.
   • Adjust the chunk size.
   • Use appropriate node type filters.
   • Implement caching for frequently accessed data.

3. API limits

   • Implement rate limiting.
   • Use pagination.
   • Cache responses when possible.

Debug Mode

Enable debug logging to get detailed information:

# Set the debug environment variable
export DEBUG=true

Development and Contribution

• Report issues: Submit any encountered issues or feature requests on GitHub Issues.
• Contribute code: Feel free to fork the repository and submit pull requests to help improve the tool.

📄 License

This project is licensed under the MIT License. Please refer to the license file for detailed information.