I don't recall if I've already submitted this enhancement...
I've written a memcached based Session that others might find useful. Feel free to use as you wish.
1. Name the file SessionMemcachedStore.py in WebKit directory
2. Configure your Application.config:
SessionStore = 'WebKit.SessionMemcachedStore'
SessionMemcachedServers = ['']
SessionTimeout = 180 # minutes

Best Regards,

import threading
from memcache import memcache
from WebKit.SessionStore import SessionStore

debug = False

class SessionMemcachedStore(SessionStore, threading.local):
    """A session memached store.

    Stores the sessions in a single memcached using 'last write wins' semantics.

    This is useful for various situations:
        1. Fault tolerance
        2. Clustering

    In clustering configurations with concurrent writes for the same
    session(s) the last writer will always overwrite the session.

    Cleaning/timing out of sessions is performed by the memcached(s) themselves
    since no one appserver can know about the existence of all sessions or
    the last access for a given session. Besides it is built in memcached
    functionality. Consequently, correct sizing of memcached(s) is necessary
    to hold all user's session data.

    ## Init ##

    def __init__(self, app):
        SessionStore.__init__(self, app)

        self._memcachedServers = app.setting(
            'MemcachedServers', [''])

        # timeout in seconds
        self._sessionTimeout = app.setting(
            'SessionTimeout', 180) * 60
        ## try:
        ##     import cPickle as pickle
        ## except ImportError:
        ##     import pickle
        import pickle
        self._client = memcache.Client(self._memcachedServers,

    ## Access ##

    def __len__(self):
        if debug:
            print '>> len', len(self.keys())
        return len(self.keys())

    def __getitem__(self, key):
        if debug:
            print '>> getitem(%s)' % (key)
        # returns None if key non-existent or no server to contact
        value = self._client.get(key)
        if value is None:
            # SessionStore expects KeyError when no result
            raise KeyError
        return value

    def __setitem__(self, key, item):
        if debug:
            print '>> setitem(%s, %s)' % (key, item)
            val = self._client.set(key, item, time=self._sessionTimeout)
            if not val:
                raise Exception
        except Exception, e:
            # Not able to store the session is a failure
            print "Error saving session '%s' to memcached: %s" % (key, e)

    def __delitem__(self, key):
        """In contracts with SessionFileStore not finding a key to delete isn't a KeyError"""
        if debug:
            print '>> delitem(%s)' % (key)

    def removeKey(self, key):

    def has_key(self, key):
        if debug:
            print ">> has_key(%s) " % (key)
        return self._client.get(key) is not None

    def keys(self):
        if debug:
            print ">> keys() "
        return []

    def clear(self):
        """memcache handles clearing keys itself"""
        if debug:
            print ">> clear() "

    def setdefault(self, key, default):
        """return value associated with key otherwise set key to default and return default"""
        if debug:
            print '>> setdefault (%s, %s)' % (key, default)
            return self[key]
        except KeyError:
            self[key] = default
            return default

    ## Application support ##

    def storeSession(self, session):
        if debug:
            print ">> storeSession(%s) " % (session)
        key = session.identifier()
        self[key] = session

    def storeAllSessions(self):