Method memorize

methods/memrl_agent.py:587–723

Store text into MemRL memory using official build strategy. This method: 1. Splits input text into manageable chunks 2. Uses MemRL's build_memory for each chunk (following official implementation) 3. Tracks progress and provides detailed logging 4. Records al

(self, text: str, **kwargs)

        return chunks

    def memorize(self, text: str, **kwargs) -> MemoryBuildResult:
        """Store text into MemRL memory using official build strategy.

        This method:
        1. Splits input text into manageable chunks
        2. Uses MemRL's build_memory for each chunk (following official implementation)
        3. Tracks progress and provides detailed logging
        4. Records all token usage through the tracked LLM provider
        """
        start_time = time.time()

        # Split text into chunks for processing
        chunks = self._split_text_into_chunks(
            text,
            max_tokens=self.memorize_chunk_tokens,
            overlap_tokens=self.memorize_chunk_overlap_tokens,
        )

        if not chunks:
            return MemoryBuildResult(
                success=False,
                method="memrl",
                action="memorize",
                input_content=text,
                stored_content="",
                memory_entries=[],
                chunk_count=0,
                extra={"error": "No chunks to process"},
            )

        # Start progress tracking
        self._build_progress.start(len(chunks))
        logger.info(f"[MemRL Memory Build] Starting memorization of {len(chunks)} chunks...")

        memory_entries: List[Dict[str, Any]] = []
        all_memory_ids: List[str] = []
        build_details: List[Dict[str, Any]] = []

        for i, chunk in enumerate(chunks):
            chunk_start = time.time()

            try:
                # Use MemRL's official build_memory method
                # Pass the full chunk as both task_description and trajectory
                # (following official implementation without artificial truncation)
                memory_id = self._memory_service.build_memory(
                    task_description=chunk,  # Full chunk as task description
                    trajectory=chunk,  # Full chunk as trajectory
                    metadata={
                        "source_benchmark": "medmemorybench",
                        "chunk_index": i,
                        "total_chunks": len(chunks),
                        # Don't assume success - let MemRL handle Q-value initialization
                    }
                )

                chunk_time = time.time() - chunk_start