Skip to content

Ray client

Bases: ToolClient

A RayToolClient connects to a Ray ToolServer and interfaces with its tools

Source code in blue/tools/clients/ray_client.py 
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
class RayToolClient(ToolClient):
    """A RayToolClient connects to a Ray ToolServer and interfaces with its tools"""

    def __init__(self, name, tools={}, properties={}):
        """Initialize a RayToolClient instance.

        Parameters:
            name: Name of the tool client
            tools: A dictionary of tool name to Tool object
            properties: Properties of the tool client
        """
        super().__init__(name, properties=properties)

        self.tools = tools

    ###### connection
    def _initialize_connection_properties(self):
        """Initialize default connection properties for Ray tool client."""
        super()._initialize_connection_properties()

        # set host, port, protocol
        self.properties['connection']['host'] = 'localhost'
        self.properties['connection']['port'] = 10001
        self.properties['connection']['protocol'] = 'ray'

    ###### connection
    def _connect(self, **connection):
        """Connect to Ray tool server."""
        c = copy.deepcopy(connection)
        if 'protocol' in c:
            del c['protocol']

        # init ray necessary
        host = c['host']
        port = c['port']
        server_url = "ray://" + host + ":" + str(port)

        namespace = None
        if 'namespace' in c:
            namespace = c['namespace']

        ray.init(address=server_url, namespace=namespace, ignore_reinit_error=True)
        return {}

    def _disconnect(self):
        """Disconnect from Ray tool server."""
        if ray.is_initialized():
            ray.shutdown()
        return None

    ######### server
    def fetch_metadata(self):
        """Fetch metadata for the Ray tool server.

        Returns:
            An empty dictionary since no metadata is necessary for Ray tool server.
        """
        return {}

    ######### tool
    def fetch_tools(self):
        """Get a list of available tools on Ray tool server.

        Returns:
            List of tool names
        """
        return list(self.tools.keys())

    def fetch_tool_metadata(self, tool):
        """Fetch metadata for a specific tool on Ray tool server.

        Parameters:
            tool: Name of the tool

        Returns:
            Metadata dictionary for the tool
        """
        metadata = {}

        if tool in self.tools:
            tool_obj = self.tools[tool]
            p = {}
            p = json_utils.merge_json(p, tool_obj.properties)
            p = json_utils.merge_json(p, {"signature": tool_obj.get_signature()})
            metadata = {"name": tool_obj.name, "description": tool_obj.description, "properties": p}
        return metadata

    ######### execute tool
    def execute_tool(self, tool, args, kwargs):
        """Execute a specific tool on Ray tool server.

        Parameters:
            tool: Name of the tool
            args: Arguments for the tool function
            kwargs: Keyword arguments for the tool function

        Raises:
            Exception: If no tool matches the given name

        Returns:
            Result of the tool execution
        """
        if tool is None:
            raise Exception("No tool matching...")

        result_ref = None

        if tool in self.tools:
            tool_obj = self.tools[tool]

            valid = tool_obj.validator(**kwargs)
            if valid:
                remote_function = ray.remote(tool_obj.function)
                result_ref = remote_function.remote(**kwargs)
            else:
                return None

        if result_ref:
            result = ray.get(result_ref)
            return result
        else:
            return None

__init__(name, tools={}, properties={})

Initialize a RayToolClient instance.

Parameters:

Name Type Description Default
name

Name of the tool client

 required
tools

A dictionary of tool name to Tool object

 {}
properties

Properties of the tool client

 {}
Source code in blue/tools/clients/ray_client.py 
23
24
25
26
27
28
29
30
31
32
33
def __init__(self, name, tools={}, properties={}):
    """Initialize a RayToolClient instance.

    Parameters:
        name: Name of the tool client
        tools: A dictionary of tool name to Tool object
        properties: Properties of the tool client
    """
    super().__init__(name, properties=properties)

    self.tools = tools

execute_tool(tool, args, kwargs)

Execute a specific tool on Ray tool server.

Parameters:

Name Type Description Default
tool

Name of the tool

 required
args

Arguments for the tool function

 required
kwargs

Keyword arguments for the tool function

 required

Raises:

Type Description
Exception

If no tool matches the given name

Returns:

Type Description

Result of the tool execution
Source code in blue/tools/clients/ray_client.py 
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
def execute_tool(self, tool, args, kwargs):
    """Execute a specific tool on Ray tool server.

    Parameters:
        tool: Name of the tool
        args: Arguments for the tool function
        kwargs: Keyword arguments for the tool function

    Raises:
        Exception: If no tool matches the given name

    Returns:
        Result of the tool execution
    """
    if tool is None:
        raise Exception("No tool matching...")

    result_ref = None

    if tool in self.tools:
        tool_obj = self.tools[tool]

        valid = tool_obj.validator(**kwargs)
        if valid:
            remote_function = ray.remote(tool_obj.function)
            result_ref = remote_function.remote(**kwargs)
        else:
            return None

    if result_ref:
        result = ray.get(result_ref)
        return result
    else:
        return None

fetch_metadata()

Fetch metadata for the Ray tool server.

Returns:

Type Description

An empty dictionary since no metadata is necessary for Ray tool server.
Source code in blue/tools/clients/ray_client.py 
71
72
73
74
75
76
77
def fetch_metadata(self):
    """Fetch metadata for the Ray tool server.

    Returns:
        An empty dictionary since no metadata is necessary for Ray tool server.
    """
    return {}

fetch_tool_metadata(tool)

Fetch metadata for a specific tool on Ray tool server.

Parameters:

Name Type Description Default
tool

Name of the tool

 required

Returns:

Type Description

Metadata dictionary for the tool
Source code in blue/tools/clients/ray_client.py 
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
def fetch_tool_metadata(self, tool):
    """Fetch metadata for a specific tool on Ray tool server.

    Parameters:
        tool: Name of the tool

    Returns:
        Metadata dictionary for the tool
    """
    metadata = {}

    if tool in self.tools:
        tool_obj = self.tools[tool]
        p = {}
        p = json_utils.merge_json(p, tool_obj.properties)
        p = json_utils.merge_json(p, {"signature": tool_obj.get_signature()})
        metadata = {"name": tool_obj.name, "description": tool_obj.description, "properties": p}
    return metadata

fetch_tools()

Get a list of available tools on Ray tool server.

Returns:

Type Description

List of tool names
Source code in blue/tools/clients/ray_client.py 
80
81
82
83
84
85
86
def fetch_tools(self):
    """Get a list of available tools on Ray tool server.

    Returns:
        List of tool names
    """
    return list(self.tools.keys())
Last update: 2025-10-07