Chunky

Chunky MCP is an MCP server that handles chunking and reading large responses so your tools can work with big data without hitting size limits. It provides a local stdio-based MCP endpoint that your client can talk to, enabling seamless large-response processing.

How to use

You connect your MCP client to the chunky MCP server using a stdio configuration. Your client can request data as normal, and the server will chunk large responses for you so your tool can process them piece by piece without running into size or memory issues.

In your tool, you import the helper that handles large responses and decorate your tool with the MCP tool decorator. When a call might return a large JSON payload, delegate the processing to the chunking helper so subsequent steps receive data in manageable chunks.

from chunky_mcp_utils import handle_large_response

@mcp.tool()
def my_tool() -> list[types.TextContent]:
    """
    Gets a list of all the employees in the system from the database
    """
    # Call might give a large JSON response
    response = requests.get("https://someblob.com")
    response_data = response.json()
    
    # Chunker handles the large response and calls following read chunk tools
    return handle_large_response(
        response_data,
        my_tool.__name__,
        _chunker
    )

What you’ll run

The MCP server entry for this project is exposed as a local (stdio) endpoint. You run it as a local process and connect to it from your tooling environment. The key details you’ll need are the command to start the server and any arguments.

Configuration you’ll use

"chunky": {
  "type": "stdio",
  "command": "chunky-mcp",
  "args": []
}

Available tools

handle_large_response

Helper function that chunks large response data and invokes subsequent read chunk tools to process the data piece by piece.

my_tool

Example MCP tool that fetches data and uses the chunking helper to process large payloads.