diff --git a/README.md b/README.md
index c3bdfa5..c13535c 100644
--- a/README.md
+++ b/README.md
@@ -60,6 +60,24 @@
 
 The web user interface will than be available for example at <http://localhost:3000>
 
+### Memory usage and caching
+
+Apart from the model itself, which is memory mapped and therefore shared
+between all workers, each worker keeps its own result caches. Their size is
+limited and can be configured in the `cache` section of the configuration file
+(see [example.conf](example.conf)):
+
+| Option                 | Default | Caches                                             |
+|------------------------|---------|----------------------------------------------------|
+| `max_keys`             | 50      | paradigmatic and syntagmatic neighbourhood results |
+| `collocators_max_keys` | 200     | classic (count-based) collocator profiles          |
+| `profiles_max_keys`    | 200     | precomputed similar profiles                       |
+
+The worst case memory footprint of the caches is
+`workers * max_keys * size of one result`, and a neighbourhood result contains
+one vector per neighbour, so `max_keys` should be kept small. Setting a limit
+to `0` disables the respective cache, as does starting the server with `-C`.
+
 ## Web Service API
 
 In addition to the web user interface, derekovecs also provides a web api which is however still very unsystematic and **not stable**. To figure out the meaning of still undocumented result components, have a look at the table head mouse-overs in the GUI or at the source code around [here](https://korap.ids-mannheim.de/gerrit/plugins/gitiles/ids-kl/derekovecs/+/refs/heads/master/templates/index.html.ep#684).
diff --git a/example.conf b/example.conf
index ddc1d2f..34d6297 100644
--- a/example.conf
+++ b/example.conf
@@ -12,6 +12,15 @@
     workers => 0
   },
 
+  # Per worker in-memory caches. The total footprint is workers * max_keys *
+  # size of a cached result, so keep max_keys small - neighbourhood results
+  # contain one vector per neighbour. 0 disables the respective cache.
+  cache => {
+    max_keys             => 50,   # neighbourhood (paradigmatic/syntagmatic) results
+    collocators_max_keys => 200,  # classic collocator profiles (JSON)
+    profiles_max_keys    => 200   # similar profiles (JSON)
+  },
+
   w2v => {
     vecs => "example-models/wpd19_10000/wpd19_10000.vecs",
     # compare_to => "https://corpora.ids-mannheim.de/openlab/derekovecs", # compare results to this derekovecs instance
diff --git a/lib/IDS/DeReKoVecs/Read.pm b/lib/IDS/DeReKoVecs/Read.pm
index 7bff3af..fffa9e5 100644
--- a/lib/IDS/DeReKoVecs/Read.pm
+++ b/lib/IDS/DeReKoVecs/Read.pm
@@ -8,12 +8,16 @@
 my $src_file      = undef;
 
 our $mergedEnd=0;
-our %cache;
-our %cccache; # classic collocator cache
-our %spcache; # similar profile cache
 our $opt_p = 5676;
 our $opt_C;
 
+# Cached values are large (a classic collocator profile is tens to hundreds of
+# kilobytes of JSON), so the caches are size limited. Without a limit a long
+# running worker accumulates one entry per queried word until the box runs out
+# of memory. Defaults can be overridden via configure_cache().
+our $CC_CACHE_MAX_KEYS = 200;  # classic collocators
+our $SP_CACHE_MAX_KEYS = 200;  # similar profiles
+
 BEGIN {
   $src_file = __FILE__;
   $src_file =~ s/Read.pm/derekovecs-server.c/;
@@ -24,9 +28,40 @@
 #use Inline C => Config => CLEAN_AFTER_BUILD => 0, ccflags => $Config{ccflags}." -Ofast -march k8 -mtune k8 ";
 
 use Mojo::JSON qw(decode_json encode_json to_json);
+use Mojo::Cache;
 use Exporter qw(import);
 
-our @EXPORT = qw(init_net load_sprofiles getVocabSize getDowntimeCalendar getCollocationAssociation getClassicCollocatorsCached getSimilarProfiles getSimilarProfilesCached getBiggestMergedDifferences filter_garbage get_neighbours getWordNumber dump_vecs dump_for_numpy cos_similarity_as_json get_version getPosWiseW2VCollocators);
+our @EXPORT = qw(init_net load_sprofiles getVocabSize getDowntimeCalendar getCollocationAssociation getClassicCollocatorsCached getSimilarProfiles getSimilarProfilesCached getBiggestMergedDifferences filter_garbage get_neighbours getWordNumber dump_vecs dump_for_numpy cos_similarity_as_json get_version getPosWiseW2VCollocators configure_cache cache_stats);
+
+my $cccache = Mojo::Cache->new(max_keys => $CC_CACHE_MAX_KEYS); # classic collocator cache
+my $spcache = Mojo::Cache->new(max_keys => $SP_CACHE_MAX_KEYS); # similar profile cache
+
+# Adjust the caches at startup, e.g.
+#   configure_cache(collocators_max_keys => 500, no_cache => 1)
+# A max_keys value <= 0 disables the respective cache. Setting a limit starts
+# from an empty cache, so that a lowered limit takes effect immediately.
+sub configure_cache {
+  my (%opt) = @_;
+  $opt_C = $opt{no_cache} if defined $opt{no_cache};
+  $cccache = Mojo::Cache->new(max_keys => $opt{collocators_max_keys})
+    if defined $opt{collocators_max_keys};
+  $spcache = Mojo::Cache->new(max_keys => $opt{profiles_max_keys})
+    if defined $opt{profiles_max_keys};
+  return;
+}
+
+sub cache_stats {
+  return {
+    collocators => {
+      keys     => scalar keys %{$cccache->{cache} || {}},
+      max_keys => $cccache->max_keys
+    },
+    profiles => {
+      keys     => scalar keys %{$spcache->{cache} || {}},
+      max_keys => $spcache->max_keys
+    }
+  };
+}
 
 sub getDowntimeCalendar {
   my ($url) = @_;
@@ -55,11 +90,13 @@
     open $pipe, "lwp-request $compare_to/getClassicCollocators?w=$word |";
   }
 
-  if($opt_C || !$cccache{$word}) {
+  my $collocators = $opt_C ? undef : $cccache->get($word);
+  if(!defined $collocators) {
     $c->app->log->info("Getting classic collocates of $word.");
-    $cccache{$word} = getClassicCollocators($word);
-    $cccache{$word} =~ s/:(-?)(nan|inf)/:"${1}${2}"/g;
-    $cccache{$word} =~ s/"""/"\\""/g;
+    $collocators = getClassicCollocators($word);
+    $collocators =~ s/:(-?)(nan|inf)/:"${1}${2}"/g;
+    $collocators =~ s/"""/"\\""/g;
+    $cccache->set($word => $collocators) unless $opt_C;
   } else {
     $c->app->log->info("Getting classic collocates for $word from cache.");
   }
@@ -72,7 +109,7 @@
   }
 
   if(length($s2) > 2000) {
-    my $d1 = decode_json($cccache{$word});
+    my $d1 = decode_json($collocators);
     my $d2 = decode_json($s2);
     my %d2ld;
     my $minLd = 14;
@@ -86,7 +123,7 @@
     }
     return(encode_json($d1));
   } else {
-    my $d1 = decode_json($cccache{$word});
+    my $d1 = decode_json($collocators);
     foreach my $i (@{$d1->{collocates}}) {
       $i->{delta} = 0;
     }
@@ -96,12 +133,14 @@
 
 sub getSimilarProfilesCached {
   my ($c, $word) = @_;
-  if(!$spcache{$word}) {
-    $spcache{$word} = getSimilarProfiles($word);
+  my $profiles = $opt_C ? undef : $spcache->get($word);
+  if(!defined $profiles) {
+    $profiles = getSimilarProfiles($word);
+    $spcache->set($word => $profiles) unless $opt_C;
   } else {
     $c->app->log->info("Getting similar profiles for $word from cache:");
   }
-  return $spcache{$word};
+  return $profiles;
 }
 
 return 1;
diff --git a/script/derekovecs-server b/script/derekovecs-server
index 1930381..b15341e 100755
--- a/script/derekovecs-server
+++ b/script/derekovecs-server
@@ -4,6 +4,7 @@
 
 use IDS::DeReKoVecs::Read;
 use Mojolicious::Lite;
+use Mojo::Cache;
 use Mojo::JSON qw(decode_json encode_json to_json);
 use base 'Mojolicious::Plugin';
 
@@ -57,12 +58,17 @@
 our $opt_G;
 
 our $mergedEnd=0;
-our %cache;
-our %cccache; # classic collocator cache
-our %spcache; # similar profile cache
 our $opt_p = 5676;
 our $opt_C;
 
+# Neighbourhood results are the biggest objects the server keeps around (one
+# hash plus one vector array per neighbour), so this cache is deliberately
+# small. It is per worker, i.e. the total footprint is
+# workers * max_keys * result size. Set cache => {max_keys => 0} to switch the
+# cache off.
+my $CACHE_MAX_KEYS = app->config->{cache}->{max_keys} // 50;
+my $cache = Mojo::Cache->new(max_keys => $CACHE_MAX_KEYS);
+
 my %marked;
 my $title="";
 my $training_args="";
@@ -82,6 +88,12 @@
 
 getopts('d:D:Gil:p:m:n:M:Ch') or usage();
 
+configure_cache(
+  no_cache             => $opt_C,
+  collocators_max_keys => app->config->{cache}->{collocators_max_keys},
+  profiles_max_keys    => app->config->{cache}->{profiles_max_keys}
+);
+
 if($opt_M) {
   open my $handle, '<:encoding(UTF-8)', $opt_M
     or die "Can't open '$opt_M' for reading: $!";
@@ -359,9 +371,10 @@
           $searchBaseVocabFirst=1;
         }
       }
-      if ($cache{$w.$cutoff.$no_nbs.$sort.$dedupe,$searchBaseVocabFirst}) {
+      my $key = join("\x1c", $w, $cutoff, $no_nbs, $sort, $dedupe, $searchBaseVocabFirst, $nosp);
+      $res = $opt_C ? undef : $cache->get($key);
+      if (defined $res) {
         $c->app->log->info("Getting $w results from cache");
-        $res = $cache{$w.$cutoff.$no_nbs.$sort.$dedupe.$searchBaseVocabFirst}
       } else {
         $c->app->log->info('Looking for neighbours of '.$w);
         if($opt_i) {
@@ -369,7 +382,7 @@
         } else {
           $res = get_neighbours($w, $no_nbs, $sort, $searchBaseVocabFirst, $cutoff, $dedupe, $nosp);
         }
-        $cache{$w.$cutoff.$no_nbs.$sort.$dedupe} = $res;
+        $cache->set($key => $res) unless $opt_C;
       }
       push(@lists, $res->{paradigmatic});
     }