simulate_heavy_computation

Execute multiple heavy computation tasks concurrently to demonstrate parallel processing benefits for SEO data analysis operations.

Instructions

Parallelized version of simulate_heavy_computation.

This function accepts a list of keyword argument dictionaries and executes simulate_heavy_computation concurrently for each set of arguments.

Original function signature: simulate_heavy_computation(complexity: int)

Args: kwargs_list (List[Dict[str, Any]]): A list of dictionaries, where each dictionary provides the keyword arguments for a single call to simulate_heavy_computation.

Returns: List[Any]: A list containing the results of each call to simulate_heavy_computation, in the same order as the input kwargs_list.

Original docstring: Simulate a heavy computation task.

This tool demonstrates parallelization benefits by performing
a computationally intensive task that can be parallelized.

Args:
    complexity: Complexity level (1-10, higher = more computation)
    
Returns:
    Dictionary containing computation results

Input Schema

TableJSON Schema

Name	Required	Description	Default
`kwargs_list`	Yes

Implementation Reference

mcp_ahrefs/tools/example_tools.py:133-169 (handler)

The core handler function implementing the simulate_heavy_computation tool. It performs a simulated heavy computation loop based on the complexity parameter, yielding control periodically for async compatibility, and returns performance metrics.

async def simulate_heavy_computation(complexity: int = 5) -> Dict[str, Any]:
    """Simulate a heavy computation task.
    
    This tool demonstrates parallelization benefits by performing
    a computationally intensive task that can be parallelized.
    
    Args:
        complexity: Complexity level (1-10, higher = more computation)
        
    Returns:
        Dictionary containing computation results
    """
    if complexity < 1 or complexity > 10:
        raise ValueError("complexity must be between 1 and 10")
    
    start_time = time.time()
    
    # Simulate heavy computation
    result = 0
    iterations = complexity * 100000  # Reduced for async context
    
    for i in range(iterations):
        result += i * 2
        if i % 10000 == 0:
            # Yield control to allow other tasks to run
            import asyncio
            await asyncio.sleep(0.001)
    
    computation_time = time.time() - start_time
    
    return {
        "complexity": complexity,
        "iterations": iterations,
        "result": result,
        "computation_time": computation_time,
        "operations_per_second": iterations / computation_time if computation_time > 0 else 0
    }

mcp_ahrefs/server/app.py:114-126 (registration)

The registration code for parallel tools, including simulate_heavy_computation. It applies SAAGA decorators (parallelize, tool_logger, exception_handler) and registers the decorated function with the MCP server using mcp_server.tool(name=tool_name).

for tool_func in parallel_example_tools:
    # Apply SAAGA decorator chain: exception_handler → tool_logger → parallelize
    decorated_func = exception_handler(tool_logger(parallelize(tool_func), config.__dict__))
    
    # Extract metadata
    tool_name = tool_func.__name__
    
    # Register directly with MCP
    mcp_server.tool(
        name=tool_name
    )(decorated_func)
    
    unified_logger.info(f"Registered parallel tool: {tool_name}")

mcp_ahrefs/tools/example_tools.py:173-175 (registration)
The list grouping simulate_heavy_computation as a parallel tool, which is imported and used in server/app.py for registration.
```
parallel_example_tools = [
    process_batch_data,
    simulate_heavy_computation
```

MCP Ahrefs