One of the enduring challenges in robotics is enabling intelligent agents to recall, persist, and reason about experiences over time. While state-of-the-art perception and control architectures can endow a robot with impressive capabilities, they often lack robust mechanisms for long-term memory. This gap becomes especially apparent in real-world mobile robots, which must not only perceive and act but also *remember*—persisting and retrieving task context across sessions, days, or even months. Integrating memory into robotic systems is thus a crucial step towards more adaptable, autonomous, and intelligent agents.

Why Memory Matters in Mobile Robotics

Consider a mobile robot navigating a dynamic warehouse, performing pick-and-place tasks. Each session, it must recall the locations of obstacles, the identities of workstations, and even details about partially completed tasks. Without memory, the robot would rely solely on its current sensor data and pre-programmed logic, leading to inefficiencies and errors. By contrast, a robot capable of *persisting* and *retrieving* task context can adapt to evolving environments, recover from interruptions, and provide seamless user experiences.

Memory is not just a convenience—it’s a prerequisite for true autonomy.

This tutorial presents a step-by-step guide to integrating Partenit memory with ROS2 (Robot Operating System 2), enabling a mobile robot to persist and recall task context across sessions. Our approach emphasizes clarity, modularity, and reproducibility, empowering you to extend and adapt the solution to your own robotic platforms.

Understanding the Architecture: ROS2 and Partenit Memory

Before we dive into implementation, let’s briefly outline our architecture:

  • ROS2 acts as the communication backbone, orchestrating perception, control, and higher-level behaviors via nodes and topics.
  • Partenit Memory provides a structured, queryable memory layer, allowing storage and retrieval of task context, episodic experiences, and semantic knowledge.

Our goal is to engineer a seamless interface between ROS2 and Partenit, so that relevant context (e.g., current task parameters, environment state, robot goals) can be automatically persisted and later retrieved—enabling continuity across sessions, failure recovery, and adaptive behavior.

Step 1: Setting Up the Environment

To get started, you will need:

  • A working ROS2 installation (e.g., Humble or Iron)
  • Python 3.8+ (recommended for ROS2 and Partenit APIs)
  • Access to the Partenit memory service (either cloud-based or self-hosted instance)
  • Your mobile robot simulation or hardware setup (for demonstration, we use a simulated TurtleBot3)

Install ROS2 according to the official documentation. Then, install the Partenit Python client:

pip install partenit-memory

Verify your environment by running:

python -c "import partenit_memory; print(partenit_memory.__version__)"

Step 2: Defining the Task Context

Memory is only as useful as the information it preserves. Thus, we must first specify what constitutes task context for your robot. This typically includes:

  • Current and previous task goals
  • Robot’s location and map state
  • Relevant objects and their states
  • Task-specific parameters (e.g., delivery location, cargo type)
  • Any user commands or overrides

For our example, suppose our TurtleBot3 is tasked with navigating to waypoints while avoiding dynamic obstacles. The context might look like this:

{
  "session_id": "2024-06-15T10:25:00Z",
  "current_task": "navigate_to_waypoint",
  "current_goal": {"x": 2.5, "y": 1.7},
  "previous_goals": [
    {"x": 0.0, "y": 0.0, "timestamp": "2024-06-15T10:20:00Z"}
  ],
  "obstacles": [
    {"type": "box", "position": {"x": 1.2, "y": 1.1}}
  ],
  "user_override": false
}

Defining a clear schema for your context is essential for robust storage and retrieval.

Step 3: Creating the ROS2 Memory Interface Node

We now create a ROS2 node responsible for two-way communication between ROS2 and Partenit Memory. This node will:

  • Subscribe to relevant topics (e.g., task updates, localization, object detection)
  • Aggregate context information into a structured message
  • Persist context to Partenit at key moments (e.g., task completion, shutdown)
  • Restore context from Partenit on startup or recovery

Let’s walk through the skeleton code for such a node in Python:

import rclpy
from rclpy.node import Node
import partenit_memory

class MemoryInterface(Node):
    def __init__(self):
        super().__init__('memory_interface')
        self.memory = partenit_memory.Client(api_key='YOUR_API_KEY')
        self.context = {}
        self.subscription = self.create_subscription(
            # Assume a custom message with task context
            TaskContextMsg, 'task_context', self.context_callback, 10
        )
        self.declare_parameter('context_key', 'robot_task_context')

    def context_callback(self, msg):
        # Convert ROS2 message to dict
        self.context = msg_to_dict(msg)
        self.get_logger().info(f"Context updated: {self.context}")

    def persist_context(self):
        key = self.get_parameter('context_key').get_parameter_value().string_value
        self.memory.save(key, self.context)
        self.get_logger().info("Context persisted to Partenit.")

    def retrieve_context(self):
        key = self.get_parameter('context_key').get_parameter_value().string_value
        restored = self.memory.load(key)
        if restored:
            self.context = restored
            self.get_logger().info("Context restored from Partenit.")
        else:
            self.get_logger().warn("No previous context found.")

def main(args=None):
    rclpy.init(args=args)
    node = MemoryInterface()
    # On startup, try to restore context
    node.retrieve_context()
    try:
        rclpy.spin(node)
    except KeyboardInterrupt:
        node.persist_context()
    node.destroy_node()
    rclpy.shutdown()

Note: Replace TaskContextMsg and msg_to_dict with your specific ROS2 message type and conversion logic. This code persists context upon shutdown and attempts to restore context on startup, ensuring continuity across sessions.

Step 4: Persisting Context at Key Moments

Deciding when to persist context is as important as what to store. In practice, you may want to trigger context persistence:

  • At regular intervals (e.g., every 30 seconds)
  • Upon task completion or major event
  • During graceful shutdown or error recovery

This can be implemented using ROS2 timers or event-driven callbacks. For example:

self.timer = self.create_timer(30.0, self.persist_context)

Or, by subscribing to a task status topic and persisting upon completion.

Handling Recovery and Continuity

When your robot restarts—after a power outage, software crash, or planned reboot—it should automatically retrieve the last known context and resume operation. This is achieved by invoking retrieve_context() early in your node’s lifecycle. Optionally, you may wish to notify users or operators that the robot is resuming from a saved state.

Graceful recovery is not just about robustness—it is foundational for trustworthy, human-centered robots.

Step 5: Querying and Reasoning over Memory

Partenit memory is more than a blob store; it provides semantic querying and retrieval capabilities. For instance, you might want your robot to:

  • Retrieve the last N completed tasks
  • Recall the last location where a specific object was seen
  • Query for episodes where a user override was issued

This is done via Partenit’s query API:

results = self.memory.query(
    filter={"user_override": True},
    sort_by="timestamp",
    limit=10
)
for r in results:
    print(f"Override at {r['timestamp']} in context: {r['current_goal']}")

Such capabilities empower your robot to reflect, learn, and explain its behavior—crucial for debugging, user transparency, and continual improvement.

Step 6: Integrating with Robot Behavior

Now that your robot can persist and retrieve context, you can leverage this memory in higher-level behaviors:

  • Task resumption: On reboot, automatically resume the last incomplete task.
  • Experience-aware planning: Use past obstacle locations to inform current navigation.
  • Personalization: Adapt to user preferences based on historical overrides.

For example, in your navigation stack, you could check the restored context for current_goal and issue a navigation command accordingly:

if self.context.get("current_task") == "navigate_to_waypoint":
    goal = self.context.get("current_goal")
    send_navigation_goal(goal["x"], goal["y"])

This closes the loop between episodic memory and real-time action.

Best Practices and Future Directions

Integrating memory is a powerful capability, but it requires careful design:

  • **Schema evolution**: As your robot’s capabilities grow, evolve the context schema in a backwards-compatible way.
  • **Security and privacy**: Sensitive or user-specific information in memory should be encrypted and access-controlled.
  • **Scalability**: For fleets of robots, use unique keys or namespaces to avoid context collisions.
  • **Explainability**: Leverage memory for explaining robot decisions to users and developers alike.

Extending to Multi-Robot Systems

Memory integration naturally extends to collaborative robotics. By sharing context across agents—using Partenit’s multi-user features or ROS2 topics—teams of robots can coordinate, share discoveries, and jointly recover from failures.

The future of robotics lies at the intersection of memory, communication, and autonomy.

By providing your robots with persistent, queryable memory, you are not merely solving a technical challenge. You are nurturing a deeper form of agency—one that learns from the past, adapts to the present, and anticipates the future. With careful design and thoughtful integration, memory transforms robots from reactive automata into true partners in dynamic, human-centered environments.

Share This Story, Choose Your Platform!