@@ -0,0 +1,7 @@
+*** Settings ***
+Suite Setup    Run Remote Tests    library_info.robot    libraryinfo.py
+Resource       remote_resource.robot
+
+*** Test Cases ***
+Load large library
+    Check Test Case    ${TESTNAME}
@@ -0,0 +1,13 @@
+*** Settings ***
+Library           Remote    http://127.0.0.1:${PORT}
+Suite Setup       Set Log Level    DEBUG
+
+*** Variables ***
+${PORT}           8270
+
+*** Test Cases ***
+Load large library
+    ${ret}=  some keyword
+    Should be equal  ${ret}  some
+    ${ret}=  keyword 7777
+    Should be equal  ${ret}  7777
@@ -0,0 +1,36 @@
+import sys
+
+from remoteserver import RemoteServer, keyword
+
+
+class BulkLoadRemoteServer(RemoteServer):
+
+    def _register_functions(self):
+        """
+        Individual get_keyword_* methods are not registered.
+        This removes the fall back scenario should get_library_information fail.
+        """
+        self.register_function(self.get_library_information)
+        self.register_function(self.run_keyword)
+
+    def get_library_information(self):
+        info_dict = dict()
+        for kw in self.get_keyword_names():
+            info_dict[kw] = dict(args=self.get_keyword_arguments(kw),
+                                 tags=self.get_keyword_tags(kw),
+                                 doc=self.get_keyword_documentation(kw))
+        return info_dict
+
+class The10001KeywordsLibrary(object):
+
+    def __init__(self):
+        def count(n): return lambda: "%d"%n
+        for i in range(10000):
+            setattr(self, "keyword_%d"%i, count(i))
+
+    def some_keyword(self):
+        return "some"
+
+
+if __name__ == '__main__':
+    BulkLoadRemoteServer(The10001KeywordsLibrary(), *sys.argv[1:])
@@ -65,11 +65,11 @@ def _format_kwo(self, arg, defaults):
 
     def get_keyword_tags(self, name):
         kw = getattr(self.library, name)
-        return getattr(kw, 'robot_tags', None)
+        return getattr(kw, 'robot_tags', [])
 
     def get_keyword_documentation(self, name):
         kw = getattr(self.library, name)
-        return inspect.getdoc(kw)
+        return inspect.getdoc(kw) or ''
 
     def run_keyword(self, name, args, kwargs=None):
         try:
 
@@ -206,6 +206,13 @@ The method, and also the exposed keyword, should return `True`
 or `False` depending on whether stopping is allowed or not. That makes it
 possible for external tools to know if stopping the server succeeded.
 
+Performance improvements at load-time can be achieved by implementing the
+`get_library_information` method. When supported by the remote server, Robot
+Framework will utilize this method to load all information in a single call.
+Without `get_library_information`, all `get_keyword_*` methods will be invoked
+separately for each individual keyword, causing significant delays when loading
+large libraries.
+
 The `Python remote server`__ can be used as a reference implementation.
 
 __ https://github.com/robotframework/PythonRemoteServer
 
@@ -16,6 +16,7 @@
 from __future__ import absolute_import
 
 from contextlib import contextmanager
+from functools import wraps
 
 try:
     import httplib
@@ -64,40 +65,63 @@ def __init__(self, uri='http://127.0.0.1:8270', timeout=None):
             timeout = timestr_to_secs(timeout)
         self._uri = uri
         self._client = XmlRpcRemoteClient(uri, timeout)
+        self._kw_cache = None
+
+    def _cached(info_type=None, default=None):
+        def decorator(f):
+            @wraps(f)
+            def wrapper(self, name=None):
+                if self._kw_cache:
+                    return self._kw_cache.get(info_type, dict()).get(name, default)
+                else:
+                    try:
+                        return f(self, name)
+                    except TypeError:
+                        return default
+            return wrapper
+        return decorator
+
+    def _build_kw_info_cache(self):
+        """
+        Single attempt to build the cache using get_library_information interface
+        cache structure:
+            { "keyword_name" : { 'args':[], 'tags':[], 'doc':"", 'types':[]},
+              "kw2"          : {...}, etc. }
+        """
+        try:
+            self._kw_cache = self._client.get_library_information()
+            self._kw_cache['__intro__'] = dict(
+                doc=self._client.get_keyword_documentation('__intro__'))
+            self._kw_cache['__init__'] = dict(
+                doc=self._client.get_keyword_documentation('__init__'))
+        except TypeError:
+            pass # Best effort failed, fall back to regular loading
 
-    def get_keyword_names(self, attempts=2):
-        for i in range(attempts):
-            time.sleep(i)
-            try:
-                return self._client.get_keyword_names()
-            except TypeError as err:
-                error = err
-        raise RuntimeError('Connecting remote server at %s failed: %s'
-                           % (self._uri, error))
+    def get_keyword_names(self):
+        self._build_kw_info_cache()
+        if self._kw_cache:
+            return self._kw_cache.keys()
+        try:
+            return self._client.get_keyword_names()
+        except TypeError as error:
+            raise RuntimeError('Connecting remote server at %s failed: %s'
+                               % (self._uri, error))
 
+    @_cached('args', default=['*args'])
     def get_keyword_arguments(self, name):
-        try:
-            return self._client.get_keyword_arguments(name)
-        except TypeError:
-            return ['*args']
+        return self._client.get_keyword_arguments(name)
 
+    @_cached('types')
     def get_keyword_types(self, name):
-        try:
-            return self._client.get_keyword_types(name)
-        except TypeError:
-            return None
+        return self._client.get_keyword_types(name)
 
+    @_cached('tags')
     def get_keyword_tags(self, name):
-        try:
-            return self._client.get_keyword_tags(name)
-        except TypeError:
-            return None
+        return self._client.get_keyword_tags(name)
 
+    @_cached('doc')
     def get_keyword_documentation(self, name):
-        try:
-            return self._client.get_keyword_documentation(name)
-        except TypeError:
-            return None
+        return self._client.get_keyword_documentation(name)
 
     def run_keyword(self, name, args, kwargs):
         coercer = ArgumentCoercer()
@@ -227,6 +251,10 @@ def _server(self):
         finally:
             server('close')()
 
+    def get_library_information(self):
+        with self._server as server:
+            return server.get_library_information()
+
     def get_keyword_names(self):
         with self._server as server:
             return server.get_keyword_names()