Tracker_store added in endpoints.yml

data/example_endpoints.yml

@@ -7,4 +7,17 @@ nlg:
   # basic_auth:
   #   username: user
   #   password: pass
-
+# example of redis external tracker store config
+tracker_store:
+  store_type: redis
+  url: http://localhost
+  db: 0
+  password: password
+  timeout: 30000
+# example of mongoDB external tracker store config
+#tracker_store:
+  #store_type: mongod
+  #url: mongodb://localhost:27017
+  #db: rasa
+  #user: username
+  #password: password

rasa_core/agent.py

@@ -32,7 +32,7 @@
 from rasa_core.policies.ensemble import SimplePolicyEnsemble, PolicyEnsemble
 from rasa_core.policies.memoization import MemoizationPolicy
 from rasa_core.processor import MessageProcessor
-from rasa_core.tracker_store import InMemoryTrackerStore, TrackerStore
+from rasa_core.tracker_store import InMemoryTrackerStore
 from rasa_core.trackers import DialogueStateTracker, EventVerbosity
 from rasa_core.utils import EndpointConfig
 from rasa_nlu.utils import is_url
@@ -648,8 +648,7 @@ def create_tracker_store(store, domain):
             store.domain = domain
             return store
         else:
-            return InMemoryTrackerStore(domain)
-
+            return InMemoryTrackerStore(domain)        
     @staticmethod
     def _create_ensemble(
             policies  # type: Union[List[Policy], PolicyEnsemble, None]

rasa_core/run.py

@@ -5,7 +5,7 @@
 
 from builtins import str
 from collections import namedtuple
-
+import os
 import argparse
 import logging
 from flask import Flask
@@ -23,8 +23,9 @@
     BUILTIN_CHANNELS)
 from rasa_core.interpreter import (
     NaturalLanguageInterpreter)
+from rasa_core.tracker_store import TrackerStore
 from rasa_core.utils import read_yaml_file, AvailableEndpoints
-
+from rasa_core.domain import TemplateDomain
 logger = logging.getLogger()  # get the root logger
 
 
@@ -217,7 +218,7 @@ def load_agent(core_model, interpreter, endpoints,
                 generator=endpoints.nlg,
                 action_endpoint=endpoints.action,
                 model_server=endpoints.model,
-                tracker_store=tracker_store,
+                tracker_store=endpoints.tracker_store,
                 wait_time_between_pulls=wait_time_between_pulls
         )
     else:
@@ -245,10 +246,12 @@ def load_agent(core_model, interpreter, endpoints,
     _endpoints = AvailableEndpoints.read_endpoints(cmdline_args.endpoints)
     _interpreter = NaturalLanguageInterpreter.create(cmdline_args.nlu,
                                                      _endpoints.nlu)
+    domain = TemplateDomain.load(os.path.join(cmdline_args.core, "domain.yml"))
+    _tracker_store = TrackerStore(domain).find_tracker_store(_endpoints.tracker_store)                                   
     _agent = load_agent(cmdline_args.core,
                         interpreter=_interpreter,
+                        tracker_store=_tracker_store,
                         endpoints=_endpoints)
-
     serve_application(_agent,
                       cmdline_args.connector,
                       cmdline_args.port,

rasa_core/tracker_store.py

@@ -30,7 +30,14 @@ def __init__(self, domain, event_broker=None):
         # type: (Optional[Domain], Optional[EventChannel]) -> None
         self.domain = domain
         self.event_broker = event_broker
-
+    def find_tracker_store(self, store=None):
+        if store is None:
+            return InMemoryTrackerStore(self.domain)
+        elif store.store_type == 'redis':
+            return RedisTrackerStore(domain=self.domain,host=store.url,db=store.db,password=store.password,record_exp=store.timeout)
+        elif store.store_type == 'mongod':
+            return MongoTrackerStore(domain=self.domain,host=store.url,db=store.db,username=store.user,password=store.password)
+
     def get_or_create_tracker(self, sender_id):
         tracker = self.retrieve(sender_id)
         if tracker is None:
@@ -124,6 +131,7 @@ def __init__(self, domain, host='localhost',
                  port=6379, db=0, password=None, event_broker=None,
                  record_exp=None):
 
+
         import redis
         self.red = redis.StrictRedis(host=host, port=port, db=db,
                                      password=password)

rasa_core/train.py

@@ -21,7 +21,8 @@
 from rasa_core.policies.memoization import MemoizationPolicy
 from rasa_core.run import AvailableEndpoints
 from rasa_core.training import interactive
-
+from rasa_core.tracker_store import TrackerStore
+from rasa_core.domain import TemplateDomain
 logger = logging.getLogger(__name__)
 
 
@@ -216,7 +217,8 @@ def train_dialogue_model(domain_file, stories_file, output_path,
     _endpoints = AvailableEndpoints.read_endpoints(cmdline_args.endpoints)
     _interpreter = NaturalLanguageInterpreter.create(cmdline_args.nlu,
                                                      _endpoints.nlu)
-
+    domain = TemplateDomain.load(cmdline_args.domain)                                                
+    _tracker_store = TrackerStore(domain).find_tracker_store(_endpoints.tracker_store)
     if cmdline_args.core:
         if not cmdline_args.interactive:
             raise ValueError("--core can only be used together with the"
@@ -230,6 +232,7 @@ def train_dialogue_model(domain_file, stories_file, output_path,
         _agent = Agent.load(cmdline_args.core,
                             interpreter=_interpreter,
                             generator=_endpoints.nlg,
+                            tracker_store=_tracker_store,
                             action_endpoint=_endpoints.action)
     else:
         if not cmdline_args.out:

rasa_core/utils.py

@@ -595,27 +595,34 @@ def read_endpoints(cls, endpoint_file):
                 endpoint_file, endpoint_type="action_endpoint")
         model = read_endpoint_config(
                 endpoint_file, endpoint_type="models")
+        tracker_store = read_endpoint_config(endpoint_file, endpoint_type="tracker_store")
 
-        return cls(nlg, nlu, action, model)
+        return cls(nlg, nlu, action, model, tracker_store)
 
-    def __init__(self, nlg=None, nlu=None, action=None, model=None):
+    def __init__(self, nlg=None, nlu=None, action=None, model=None,tracker_store=None):
         self.model = model
         self.action = action
         self.nlu = nlu
         self.nlg = nlg
+        self.tracker_store = tracker_store
 
 
 class EndpointConfig(object):
     """Configuration for an external HTTP endpoint."""
 
     def __init__(self, url, params=None, headers=None, basic_auth=None,
-                 token=None, token_name="token"):
+                 token=None, token_name="token",store_type=None,db=None,user=None,password=None,timeout=None):
         self.url = url
         self.params = params if params else {}
         self.headers = headers if headers else {}
         self.basic_auth = basic_auth
         self.token = token
         self.token_name = token_name
+        self.store_type = store_type
+        self.db = db
+        self.user = user
+        self.password= password
+        self.timeout = timeout
 
     def request(self,
                 method="post",  # type: Text
@@ -672,7 +679,12 @@ def from_dict(cls, data):
                 data.get("headers"),
                 data.get("basic_auth"),
                 data.get("token"),
-                data.get("token_name"))
+                data.get("token_name"),
+                data.get("store_type"),
+                data.get("db"),
+                data.get("user"),
+                data.get("password"),
+                data.get("timeout"))
 
     def __eq__(self, other):
         if isinstance(self, type(other)):