refactor: demos rewrite, rai_interfaces import guards, remove legacy packages (#449)

Author: maciejmajek

examples/agriculture-demo.py

@@ -15,16 +15,13 @@
 import argparse
 
 import rclpy
-from rai.node import RaiStateBasedLlmNode, describe_ros_image
-from rai.tools.ros.native import (
-    GetCameraImage,
-    GetMsgFromTopic,
-    Ros2GenericServiceCaller,
-    Ros2GetRobotInterfaces,
-    Ros2ShowMsgInterfaceTool,
-)
+from langchain_core.messages import HumanMessage
+from langchain_core.runnables import Runnable
+from rai.agents.conversational_agent import State, create_conversational_agent
+from rai.communication.ros2.connectors import ROS2ARIConnector
+from rai.tools.ros2.topics import ROS2TopicsToolkit
 from rai.tools.time import WaitForSecondsTool
-from rclpy.action import ActionClient
+from rai.utils.model_initialization import get_llm_model
 from rclpy.callback_groups import ReentrantCallbackGroup
 from rclpy.executors import MultiThreadedExecutor
 from rclpy.node import Node
@@ -34,9 +31,10 @@
 
 
 class MockBehaviorTreeNode(Node):
-    def __init__(self, tractor_number: int):
+    def __init__(self, tractor_number: int, agent: Runnable[State, State]):
         super().__init__(f"mock_behavior_tree_node_{tractor_number}")
         self.tractor_number = tractor_number
+        self.agent = agent
 
         # Create a callback group for concurrent execution
         self.callback_group = ReentrantCallbackGroup()
@@ -48,11 +46,6 @@ def __init__(self, tractor_number: int):
             callback_group=self.callback_group,
         )
 
-        # Create action client
-        self.perform_task_client = ActionClient(
-            self, Task, "/perform_task", callback_group=self.callback_group
-        )
-
         # Create timer for periodic checks
         self.create_timer(
             5.0, self.check_tractor_state, callback_group=self.callback_group
@@ -79,18 +72,7 @@ async def check_tractor_state(self):
             goal_msg.description = ""
             goal_msg.task = "Anomaly detected. Please decide what to do."
 
-            self.perform_task_client.wait_for_server()
-
-            future = self.perform_task_client.send_goal_async(goal_msg)
-            await future
-
-            goal_handle = future.result()
-            if goal_handle.accepted:
-                self.get_logger().info("Goal accepted by perform_task action server")
-                result = await goal_handle.get_result_async()
-                self.get_logger().info(f"Result: {result.result}")
-            else:
-                self.get_logger().warn("Goal rejected by perform_task action server")
+            self.agent.invoke(State(messages=[HumanMessage(content=str(goal_msg))]))
 
 
 def main():
@@ -105,30 +87,9 @@ def main():
     args = parser.parse_args()
 
     tractor_number = args.tractor_number
-    tractor_prefix = f"/tractor{tractor_number}"
 
     rclpy.init()
 
-    observe_topics = [
-        f"{tractor_prefix}/camera_image_color",
-    ]
-
-    observe_postprocessors = {
-        f"{tractor_prefix}/camera_image_color": describe_ros_image
-    }
-
-    topics_allowlist = [
-        "/rosout",
-        f"{tractor_prefix}/camera_image_color",
-        # Services
-        f"{tractor_prefix}/continue",
-        f"{tractor_prefix}/current_state",
-        f"{tractor_prefix}/flash",
-        f"{tractor_prefix}/replan",
-    ]
-
-    actions_allowlist = []
-
     SYSTEM_PROMPT = f"""
     You are autonomous tractor {tractor_number} operating in an agricultural field. You are activated whenever the tractor stops due to an unexpected situation. Your task is to call a service based on your assessment of the situation.
 
@@ -142,35 +103,28 @@ def main():
 
     Important: You must call only one service. The tractor can only handle one service call.
     """
-
-    rai_node = RaiStateBasedLlmNode(
-        observe_topics=observe_topics,
-        observe_postprocessors=observe_postprocessors,
-        allowlist=topics_allowlist + actions_allowlist,
+    connector = ROS2ARIConnector()
+    agent = create_conversational_agent(
+        llm=get_llm_model("complex_model"),
         system_prompt=SYSTEM_PROMPT,
         tools=[
-            Ros2ShowMsgInterfaceTool,
-            WaitForSecondsTool,
-            GetMsgFromTopic,
-            GetCameraImage,
-            Ros2GetRobotInterfaces,
-            Ros2GenericServiceCaller,
+            *ROS2TopicsToolkit(connector=connector).get_tools(),
+            WaitForSecondsTool(),
         ],
     )
 
-    mock_node = MockBehaviorTreeNode(tractor_number)
+    mock_node = MockBehaviorTreeNode(tractor_number, agent)
 
     # Use a MultiThreadedExecutor to allow for concurrent execution
     executor = MultiThreadedExecutor()
-    executor.add_node(rai_node)
     executor.add_node(mock_node)
 
     try:
         executor.spin()
     except KeyboardInterrupt:
         pass
     finally:
-        rai_node.destroy_node()
+        connector.shutdown()
         mock_node.destroy_node()
         rclpy.shutdown()
 

examples/rosbot-xl-demo.py

@@ -1,4 +1,4 @@
-# Copyright (C) 2024 Robotec.AI
+# Copyright (C) 2025 Robotec.AI
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -11,57 +11,24 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-import argparse
-from pathlib import Path
-from typing import Optional
+
+from typing import cast
 
 import rclpy
 import rclpy.executors
 import rclpy.logging
-from rai.node import RaiStateBasedLlmNode
-from rai.tools.ros.native import (
-    GetMsgFromTopic,
-    Ros2GetRobotInterfaces,
-    Ros2PubMessageTool,
-    Ros2ShowMsgInterfaceTool,
-)
-from rai.tools.ros.native_actions import (
-    GetTransformTool,
-    Ros2CancelAction,
-    Ros2GetActionResult,
-    Ros2GetLastActionFeedback,
-    Ros2RunActionAsync,
-)
+from langchain_core.messages import BaseMessage, HumanMessage
+from rai.agents.conversational_agent import State, create_conversational_agent
+from rai.communication.ros2.connectors import ROS2ARIConnector
+from rai.tools.ros2.actions import ROS2ActionToolkit
+from rai.tools.ros2.topics import ROS2TopicsToolkit
 from rai.tools.time import WaitForSecondsTool
+from rai.utils.model_initialization import get_llm_model
 from rai_open_set_vision.tools import GetDetectionTool, GetDistanceToObjectsTool
 
-p = argparse.ArgumentParser()
-p.add_argument("--allowlist", type=Path, required=False, default=None)
-
 
-def main(allowlist: Optional[Path] = None):
+def main():
     rclpy.init()
-    # observe_topics = [
-    #     "/camera/camera/color/image_raw",
-    # ]
-    #
-    # observe_postprocessors = {"/camera/camera/color/image_raw": describe_ros_image}
-    ros2_allowlist = []
-    if allowlist is not None:
-        try:
-            content = allowlist.read_text().strip()
-            if content:
-                ros2_allowlist = content.splitlines()
-            else:
-                rclpy.logging.get_logger("rosbot_xl_demo").warning(
-                    "Allowlist file is empty"
-                )
-        except Exception as e:
-            rclpy.logging.get_logger("rosbot_xl_demo").error(
-                f"Failed to read allowlist: {e}"
-            )
-    else:
-        ros2_allowlist = None
 
     SYSTEM_PROMPT = """You are an autonomous robot connected to ros2 environment. Your main goal is to fulfill the user's requests.
     Do not make assumptions about the environment you are currently in.
@@ -114,32 +81,31 @@ def main(allowlist: Optional[Path] = None):
     (0.92, 1.01, 0.0)
     """
 
-    node = RaiStateBasedLlmNode(
-        observe_topics=None,
-        observe_postprocessors=None,
-        allowlist=ros2_allowlist,
+    connector = ROS2ARIConnector()
+    ros2_action_toolkit = ROS2ActionToolkit(connector=connector)
+    ros2_topics_toolkit = ROS2TopicsToolkit(connector=connector)
+
+    agent = create_conversational_agent(
+        llm=get_llm_model("complex_model"),
         system_prompt=SYSTEM_PROMPT,
         tools=[
-            Ros2GetRobotInterfaces,
-            Ros2PubMessageTool,
-            Ros2RunActionAsync,
-            Ros2CancelAction,
-            Ros2GetActionResult,
-            Ros2GetLastActionFeedback,
-            Ros2ShowMsgInterfaceTool,
-            GetTransformTool,
-            WaitForSecondsTool,
-            GetMsgFromTopic,
-            GetDetectionTool,
-            GetDistanceToObjectsTool,
+            *ros2_action_toolkit.get_tools(),
+            *ros2_topics_toolkit.get_tools(),
+            WaitForSecondsTool(),
+            GetDetectionTool(connector=connector, node=connector.node),
+            GetDistanceToObjectsTool(connector=connector, node=connector.node),
         ],
     )
-    node.declare_parameter("conversion_ratio", 1.0)
+    connector.node.declare_parameter("conversion_ratio", 1.0)
 
-    node.spin()
+    state = State(messages=[])
+    while rclpy.ok():
+        user_input = input("Enter your message: ")
+        state["messages"].append(HumanMessage(content=user_input))
+        response = agent.invoke(state)
+        cast(BaseMessage, response["messages"][-1]).pretty_print()
     rclpy.shutdown()
 
 
 if __name__ == "__main__":
-    args = p.parse_args()
-    main(**vars(args))
+    main()