diff --git a/sumpy/expansion/__init__.py b/sumpy/expansion/__init__.py
index 9d3a917a9a16516bf6968a0446eccc0886554ed2..9c6a84ae1569d32a336d9db96a00a99117f20485 100644
--- a/sumpy/expansion/__init__.py
+++ b/sumpy/expansion/__init__.py
@@ -57,6 +57,7 @@ class ExpansionBase(object):
     .. automethod:: translate_from
     .. automethod:: __eq__
     .. automethod:: __ne__
+    .. automethod:: get_kernel_derivative_taker
     """
 
     def __init__(self, kernel, order, use_rscale=None):
@@ -155,6 +156,13 @@ class ExpansionBase(object):
     def __ne__(self, other):
         return not self.__eq__(other)
 
+    def get_kernel_derivative_taker(self, dvec):
+        """Return a MiDerivativeTaker instance that supports taking
+        derivatives of the kernel with respect to dvec
+        """
+        from sumpy.tools import MiDerivativeTaker
+        return MiDerivativeTaker(self.kernel.get_expression(dvec), dvec)
+
 # }}}
 
 
diff --git a/sumpy/expansion/local.py b/sumpy/expansion/local.py
index 5db686dc7fc295b60fbdde6c48dd1f2ac2db384e..3879f50d9f3d0c404dd3a697ae51fe125153d873 100644
--- a/sumpy/expansion/local.py
+++ b/sumpy/expansion/local.py
@@ -123,7 +123,7 @@ class VolumeTaylorLocalExpansionBase(LocalExpansionBase):
         from sumpy.tools import MiDerivativeTakerWrapper
 
         result = []
-        taker = self.kernel.get_derivative_taker(avec)
+        taker = self.get_kernel_derivative_taker(avec)
         for mi in self.get_coefficient_identifiers():
             wrapper = MiDerivativeTakerWrapper(taker, mi)
             mi_expr = self.kernel.postprocess_at_source(wrapper, avec)
@@ -175,7 +175,7 @@ class VolumeTaylorLocalExpansionBase(LocalExpansionBase):
             # This code speeds up derivative taking by caching all kernel
             # derivatives.
 
-            taker = src_expansion.kernel.get_derivative_taker(dvec)
+            taker = src_expansion.get_kernel_derivative_taker(dvec)
 
             from sumpy.tools import add_mi, _fft_uneval_expr
             from pytools import generate_nonnegative_integer_tuples_below as gnitb
@@ -205,7 +205,7 @@ class VolumeTaylorLocalExpansionBase(LocalExpansionBase):
 
             # The vector has the kernel derivatives and depends only on the distance
             # between the two centers
-            taker = src_expansion.kernel.get_derivative_taker(dvec)
+            taker = src_expansion.get_kernel_derivative_taker(dvec)
             vector_stored = []
             # Calculate the kernel derivatives for the compressed set
             for term in \
diff --git a/sumpy/expansion/multipole.py b/sumpy/expansion/multipole.py
index 8186e460736472a67c87ba883c8ff0f90dc0e9cc..c4b7f098f44a9f7e69c83878b736486381095cca 100644
--- a/sumpy/expansion/multipole.py
+++ b/sumpy/expansion/multipole.py
@@ -104,7 +104,7 @@ class VolumeTaylorMultipoleExpansionBase(MultipoleExpansionBase):
         if knl is None:
             knl = self.kernel
 
-        taker = knl.get_derivative_taker(bvec)
+        taker = self.get_kernel_derivative_taker(bvec)
         expr_dict = {(0,)*self.dim: 1}
         expr_dict = knl.get_derivative_transformation_at_target(expr_dict)
         pp_nderivatives = single_valued(sum(mi) for mi in expr_dict.keys())
diff --git a/sumpy/kernel.py b/sumpy/kernel.py
index e020841d2433b2b88215560d9be5567aaf3cdfe6..e470e48d99b1c601f9ef3c881d6058b8f39f5d0c 100644
--- a/sumpy/kernel.py
+++ b/sumpy/kernel.py
@@ -127,7 +127,6 @@ class Kernel(object):
     .. automethod:: adjust_for_kernel_scaling
     .. automethod:: postprocess_at_source
     .. automethod:: postprocess_at_target
-    .. automethod:: get_derivative_taker
     .. automethod:: get_global_scaling_const
     .. automethod:: get_args
     .. automethod:: get_source_args
@@ -356,13 +355,6 @@ class Kernel(object):
         """
         return []
 
-    def get_derivative_taker(self, dvec):
-        """Return a MiDerivativeTaker instance that supports taking the
-        derivatives of this kernel
-        """
-        from sumpy.tools import MiDerivativeTaker
-        return MiDerivativeTaker(self.get_expression(dvec), dvec)
-
 # }}}
 
 
@@ -497,13 +489,6 @@ class LaplaceKernel(ExpressionKernel):
     def __repr__(self):
         return "LapKnl%dD" % self.dim
 
-    def get_derivative_taker(self, dvec):
-        from sumpy.tools import Laplace3DDerivativeTaker, MiDerivativeTaker
-        if self.dim == 3:
-            return Laplace3DDerivativeTaker(self.get_expression(dvec), dvec)
-        else:
-            return MiDerivativeTaker(self.get_expression(dvec), dvec)
-
     mapper_method = "map_laplace_kernel"
 
 
diff --git a/sumpy/symbolic.py b/sumpy/symbolic.py
index b63fca68d9d5bc2ef7e4472585ac46520c9da88a..0fed239d30b04fe38360efee190de5f38b66293b 100644
--- a/sumpy/symbolic.py
+++ b/sumpy/symbolic.py
@@ -82,11 +82,11 @@ if USE_SYMENGINE:
     import symengine as sym
     from pymbolic.interop.symengine import (
         PymbolicToSymEngineMapper as PymbolicToSympyMapper,
-        SymEngineToPymbolicMapper as SympyToPymbolicMapper, make_cse)
+        SymEngineToPymbolicMapper as SympyToPymbolicMapper)
 else:
     import sympy as sym
     from pymbolic.interop.sympy import (
-        PymbolicToSympyMapper, SympyToPymbolicMapper, make_cse)
+        PymbolicToSympyMapper, SympyToPymbolicMapper)
 
 for _apifunc in SYMBOLIC_API:
     globals()[_apifunc] = getattr(sym, _apifunc)
diff --git a/sumpy/tools.py b/sumpy/tools.py
index 34936601ba10df97b70950ccdd3e7e2941c65b6b..c2b9b1329f0aa3f94662702972ad61b8a64e451c 100644
--- a/sumpy/tools.py
+++ b/sumpy/tools.py
@@ -142,10 +142,10 @@ class MiDerivativeTaker(object):
             key=lambda other_mi: sum(self.mi_dist(mi, other_mi)))
 
 
-class Laplace3DDerivativeTaker(MiDerivativeTaker):
+class LaplaceDerivativeTaker(MiDerivativeTaker):
 
     def __init__(self, expr, var_list):
-        super(Laplace3DDerivativeTaker, self).__init__(expr, var_list)
+        super(LaplaceDerivativeTaker, self).__init__(expr, var_list)
         self.r = sym.sqrt(sum(v**2 for v in var_list))
 
     def diff(self, mi):
@@ -155,7 +155,7 @@ class Laplace3DDerivativeTaker(MiDerivativeTaker):
         try:
             expr = self.cache_by_mi[mi]
         except KeyError:
-            if max(mi) == 1:
+            if max(mi) == 1 or len(self.var_list) == 2:
                 return MiDerivativeTaker.diff(self, mi)
             d = -1
             for i in range(3):
@@ -170,10 +170,12 @@ class Laplace3DDerivativeTaker(MiDerivativeTaker):
                 mi_minus_two = list(mi)
                 mi_minus_two[i] -= 2
                 if i == d:
-                    expr -= (2*mi[i]-1)*self.var_list[i]*self.diff(tuple(mi_minus_one))
+                    expr -= (2*mi[i]-1)*self.var_list[i]*self.diff(
+                                tuple(mi_minus_one))
                     expr -= (mi[i]-1)**2*self.diff(tuple(mi_minus_two))
                 else:
-                    expr -= (2*mi[i])*self.var_list[i]*self.diff(tuple(mi_minus_one))
+                    expr -= (2*mi[i])*self.var_list[i]*self.diff(
+                                tuple(mi_minus_one))
                     expr -= mi[i]*(mi[i]-1)*self.diff(tuple(mi_minus_two))
             expr /= self.r**2
             self.cache_by_mi[mi] = expr
diff --git a/test/test_kernels.py b/test/test_kernels.py
index a1d5fec4b9485023cd9ed3aebfaebcae8cc13f93..64c5b217097db9b8e2987602ab423340cedb5264 100644
--- a/test/test_kernels.py
+++ b/test/test_kernels.py
@@ -366,7 +366,7 @@ def _m2l_translate_simple(tgt_expansion, src_expansion, src_coeff_exprs, src_rsc
     #
     # To get the local expansion coefficients, we take derivatives of
     # the multipole expansion.
-    taker = src_expansion.kernel.get_derivative_taker(dvec)
+    taker = src_expansion.get_kernel_derivative_taker(dvec)
 
     from sumpy.tools import add_mi