MemoryOS 0.0.1__py3-none-any.whl → 0.1.13__py3-none-any.whl

memos/mem_reader/memory.py

@@ -0,0 +1,298 @@
+from datetime import datetime
+from typing import Any
+
+from memos.llms.base import BaseLLM
+
+
+class Memory:
+    """Class representing the memory structure for storing and organizing memory content."""
+
+    def __init__(
+        self,
+        user_id: str,
+        session_id: str,
+        created_at: datetime,
+    ):
+        """
+        Initialize the Memory structure.
+
+        Args:
+            user_id: User identifier
+            session_id: Session identifier
+            created_at: Creation timestamp
+        """
+        self.objective_memory: dict[str, dict[str, Any]] = {}
+        self.subjective_memory: dict[str, dict[str, Any]] = {}
+        self.scene_memory = {
+            "qa_pair": {
+                "section": [],
+                "info": {
+                    "user_id": user_id,
+                    "session_id": session_id,
+                    "created_at": created_at,
+                    "summary": "",
+                    "label": [],
+                },
+            },
+            "document": {
+                "section": [],
+                "info": {
+                    "user_id": user_id,
+                    "session_id": session_id,
+                    "created_at": created_at,
+                    "doc_type": "",  # pdf, txt, etc.
+                    "doc_category": "",  # research_paper, news, etc.
+                    "doc_name": "",
+                    "summary": "",
+                    "label": [],
+                },
+            },
+        }
+
+    def to_dict(self) -> dict[str, Any]:
+        """
+        Convert the Memory object to a dictionary.
+
+        Returns:
+            Dictionary representation of the Memory object
+        """
+        return {
+            "objective_memory": self.objective_memory,
+            "subjective_memory": self.subjective_memory,
+            "scene_memory": self.scene_memory,
+        }
+
+    def update_user_memory(
+        self,
+        memory_type: str,
+        key: str,
+        value: Any,
+        origin_data: str,
+        confidence_score: float = 1.0,
+        timestamp: str | None = None,
+    ) -> None:
+        """
+        Update a memory item in either objective_memory or subjective_memory.
+        If a key already exists, the new memory item's info will replace the existing one,
+        and the values will be connected.
+
+        Args:
+            memory_type: Type of memory to update ('objective' or 'subjective')
+            key: Key for the memory item. Must be one of:
+
+                | Memory Type       | Key                  | Description                                             |
+                |-------------------|----------------------|---------------------------------------------------------|
+                | objective_memory  | nickname             | User's preferred name or alias                          |
+                | objective_memory  | gender               | User's gender (male, female, other)                     |
+                | objective_memory  | personality          | User's personality traits or MBTI type                  |
+                | objective_memory  | birth                | User's birthdate or age information                     |
+                | objective_memory  | education            | User's educational background                           |
+                | objective_memory  | work                 | User's professional history                             |
+                | objective_memory  | achievement          | User's notable accomplishments                          |
+                | objective_memory  | occupation           | User's current job or role                              |
+                | objective_memory  | residence            | User's home location or living situation                |
+                | objective_memory  | location             | User's current geographical location                    |
+                | objective_memory  | income               | User's financial information                            |
+                | objective_memory  | preference           | User's likes and dislikes                               |
+                | objective_memory  | expertise            | User's skills and knowledge areas                       |
+                | objective_memory  | language             | User's language proficiency                             |
+                | objective_memory  | hobby                | User's recreational activities                          |
+                | objective_memory  | goal                 | User's long-term aspirations                            |
+                |-------------------|----------------------|---------------------------------------------------------|
+                | subjective_memory | current_mood         | User's current emotional state                          |
+                | subjective_memory | response_style       | User's preferred interaction style                      |
+                | subjective_memory | language_style       | User's language patterns and preferences                |
+                | subjective_memory | information_density  | User's preference for detail level in responses         |
+                | subjective_memory | interaction_pace     | User's preferred conversation speed and frequency       |
+                | subjective_memory | followed_topic       | Topics the user is currently interested in              |
+                | subjective_memory | current_goal         | User's immediate objectives in the conversation         |
+                | subjective_memory | content_type         | User's preferred field of interest (e.g., technology, finance, etc.)               |
+                | subjective_memory | role_preference      | User's preferred assistant role (e.g., domain expert, translation assistant, etc.) |
+
+            value: Value to store
+            origin_data: Original data that led to this memory
+            confidence_score: Confidence score (0.0 to 1.0)
+            timestamp: Timestamp string, if None current time will be used
+        """
+        if timestamp is None:
+            timestamp = datetime.now()
+
+        memory_item = {
+            "value": value,
+            "info": {
+                "timestamp": timestamp,
+                "confidence_score": confidence_score,
+                "origin_data": origin_data,
+            },
+        }
+
+        if memory_type == "objective":
+            memory_dict = self.objective_memory
+        elif memory_type == "subjective":
+            memory_dict = self.subjective_memory
+        else:
+            raise ValueError(
+                f"Invalid memory_type: {memory_type}. Must be 'objective' or 'subjective'."
+            )
+
+        # Check if key already exists
+        if key in memory_dict:
+            existing_item = memory_dict[key]
+
+            # Connect the values (keep history but present as a connected string)
+            combined_value = f"{existing_item['value']} | {value}"
+
+            # Update the memory item with combined value and new info (using the newest info)
+            memory_dict[key] = {
+                "value": combined_value,
+                "info": memory_item["info"],  # Use the new info
+            }
+        else:
+            # If key doesn't exist, simply add the new memory item
+            memory_dict[key] = memory_item
+
+    def add_qa_batch(
+        self, batch_summary: str, pair_summaries: list[dict], themes: list[str], order: int
+    ) -> None:
+        """
+        Add a batch of Q&A pairs to the scene memory as a single subsection.
+
+        Args:
+            batch_summary: The summary of the entire batch
+            pair_summaries: List of dictionaries, each containing:
+                - question: The summarized question for a single pair
+                - summary: The original dialogue for a single pair
+                - prompt: The prompt used for summarization
+                - time: The extracted time information (if any)
+            themes: List of themes associated with the batch
+            order: Order of the batch in the sequence
+        """
+        qa_subsection = {
+            "subsection": {},
+            "info": {
+                "summary": batch_summary,
+                "label": themes,
+                "origin_data": "",
+                "order": order,
+            },
+        }
+
+        for pair in pair_summaries:
+            qa_subsection["subsection"][pair["question"]] = {
+                "summary": pair["summary"],
+                "sources": pair["prompt"].split("\n\n", 1)[-1],
+                "time": pair.get("time", ""),  # Add time field with default empty string
+            }
+
+        self.scene_memory["qa_pair"]["section"].append(qa_subsection)
+
+    def add_document_chunk_group(
+        self, summary: str, label: list[str], order: int, sub_chunks: list
+    ) -> None:
+        """
+        Add a group of document chunks as a single section with multiple facts in the subsection.
+
+        Args:
+            summary: The summary of the large chunk
+            label: List of theme labels for the large chunk
+            order: Order of the large chunk in the sequence
+            sub_chunks: List of dictionaries containing small chunks information,
+                        each with keys: 'question', 'chunk_text', 'prompt'
+        """
+        doc_section = {
+            "subsection": {},
+            "info": {
+                "summary": summary,
+                "label": label,
+                "origin_data": "",
+                "order": order,
+            },
+        }
+
+        # Add each small chunk as a fact in the subsection
+        for sub_chunk in sub_chunks:
+            question = sub_chunk["question"]
+            doc_section["subsection"][question] = {
+                "summary": sub_chunk["chunk_text"],
+                "sources": sub_chunk["prompt"].split("\n\n", 1)[-1],
+            }
+
+        self.scene_memory["document"]["section"].append(doc_section)
+
+    def process_qa_pair_summaries(self, llm: BaseLLM | None = None) -> None:
+        """
+        Process all qa_pair subsection summaries to generate a section summary.
+
+        Args:
+            llm: Optional LLM instance to generate summary. If None, concatenates subsection summaries.
+        Returns:
+            The generated section summary
+        """
+        all_summaries = []
+        all_labels = set()
+
+        # Collect all subsection summaries and labels
+        for section in self.scene_memory["qa_pair"]["section"]:
+            if "info" in section and "summary" in section["info"]:
+                all_summaries.append(section["info"]["summary"])
+            if "info" in section and "label" in section["info"]:
+                all_labels.update(section["info"]["label"])
+
+        # Generate summary
+        if llm is not None:
+            # Use LLM to generate a coherent summary
+            all_summaries_str = "\n".join(all_summaries)
+            messages = [
+                {
+                    "role": "user",
+                    "content": f"Summarize this text into a concise and objective sentence that captures its main idea. Provide only the required content directly, without including any additional information.\n\n{all_summaries_str}",
+                }
+            ]
+            section_summary = llm.generate(messages)
+        else:
+            # Simple concatenation of summaries
+            section_summary = " ".join(all_summaries)
+
+        # Update the section info
+        self.scene_memory["qa_pair"]["info"]["summary"] = section_summary
+        self.scene_memory["qa_pair"]["info"]["label"] = list(all_labels)
+
+    def process_document_summaries(self, llm=None) -> str:
+        """
+        Process all document subsection summaries to generate a section summary.
+
+        Args:
+            llm: Optional LLM instance to generate summary. If None, concatenates subsection summaries.
+        Returns:
+            The generated section summary
+        """
+        all_summaries = []
+        all_labels = set()
+
+        # Collect all subsection summaries and labels
+        for section in self.scene_memory["document"]["section"]:
+            if "info" in section and "summary" in section["info"]:
+                all_summaries.append(section["info"]["summary"])
+            if "info" in section and "label" in section["info"]:
+                all_labels.update(section["info"]["label"])
+
+        # Generate summary
+        if llm is not None:
+            # Use LLM to generate a coherent summary
+            all_summaries_str = "\n".join(all_summaries)
+            messages = [
+                {
+                    "role": "user",
+                    "content": f"Summarize this text into a concise and objective sentence that captures its main idea. Provide only the required content directly, without including any additional information.\n\n{all_summaries_str}",
+                }
+            ]
+            section_summary = llm.generate(messages)
+        else:
+            # Simple concatenation of summaries
+            section_summary = " ".join(all_summaries)
+
+        # Update the section info
+        self.scene_memory["document"]["info"]["summary"] = section_summary
+        self.scene_memory["document"]["info"]["label"] = list(all_labels)
+
+        return section_summary

memos/mem_reader/simple_struct.py

@@ -0,0 +1,241 @@
+import concurrent.futures
+import copy
+import json
+
+from abc import ABC
+from typing import Any
+
+from memos import log
+from memos.chunkers import ChunkerFactory
+from memos.configs.mem_reader import SimpleStructMemReaderConfig
+from memos.configs.parser import ParserConfigFactory
+from memos.embedders.factory import EmbedderFactory
+from memos.llms.factory import LLMFactory
+from memos.mem_reader.base import BaseMemReader
+from memos.memories.textual.item import TextualMemoryItem, TreeNodeTextualMemoryMetadata
+from memos.parsers.factory import ParserFactory
+from memos.templates.mem_reader_prompts import (
+    SIMPLE_STRUCT_DOC_READER_PROMPT,
+    SIMPLE_STRUCT_MEM_READER_PROMPT,
+)
+
+
+logger = log.get_logger(__name__)
+
+
+class SimpleStructMemReader(BaseMemReader, ABC):
+    """Naive implementation of MemReader."""
+
+    def __init__(self, config: SimpleStructMemReaderConfig):
+        """
+        Initialize the NaiveMemReader with configuration.
+
+        Args:
+            config: Configuration object for the reader
+        """
+        self.config = config
+        self.llm = LLMFactory.from_config(config.llm)
+        self.embedder = EmbedderFactory.from_config(config.embedder)
+        self.chunker = ChunkerFactory.from_config(config.chunker)
+
+    def _process_chat_data(self, scene_data_info, info):
+        prompt = (
+            SIMPLE_STRUCT_MEM_READER_PROMPT.replace("${user_a}", "user")
+            .replace("${user_b}", "assistant")
+            .replace("${conversation}", "\n".join(scene_data_info))
+        )
+
+        messages = [{"role": "user", "content": prompt}]
+
+        response_text = self.llm.generate(messages)
+        response_json = self.parse_json_result(response_text)
+
+        chat_read_nodes = []
+        for memory_i_raw in response_json.get("memory list", []):
+            node_i = TextualMemoryItem(
+                memory=memory_i_raw.get("value", ""),
+                metadata=TreeNodeTextualMemoryMetadata(
+                    user_id=info.get("user_id"),
+                    session_id=info.get("session_id"),
+                    memory_type=memory_i_raw.get("memory_type", ""),
+                    status="activated",
+                    tags=memory_i_raw.get("tags", ""),
+                    key=memory_i_raw.get("key", ""),
+                    embedding=self.embedder.embed([memory_i_raw.get("value", "")])[0],
+                    usage=[],
+                    sources=scene_data_info,
+                    background=response_json.get("summary", ""),
+                    confidence=0.99,
+                    type="fact",
+                ),
+            )
+            chat_read_nodes.append(node_i)
+
+        return chat_read_nodes
+
+    def get_memory(
+        self, scene_data: list, type: str, info: dict[str, Any]
+    ) -> list[list[TextualMemoryItem]]:
+        """
+        Extract and classify memory content from scene_data.
+        For dictionaries: Use LLM to summarize pairs of Q&A
+        For file paths: Use chunker to split documents and LLM to summarize each chunk
+
+        Args:
+            scene_data: List of dialogue information or document paths
+            type: Type of scene_data: ['doc', 'chat']
+            info: Dictionary containing user_id and session_id.
+                Must be in format: {"user_id": "1111", "session_id": "2222"}
+                Optional parameters:
+                - topic_chunk_size: Size for large topic chunks (default: 1024)
+                - topic_chunk_overlap: Overlap for large topic chunks (default: 100)
+                - chunk_size: Size for small chunks (default: 256)
+                - chunk_overlap: Overlap for small chunks (default: 50)
+        Returns:
+            list[list[TextualMemoryItem]] containing memory content with summaries as keys and original text as values
+        Raises:
+            ValueError: If scene_data is empty or if info dictionary is missing required fields
+        """
+        if not scene_data:
+            raise ValueError("scene_data is empty")
+
+        # Validate info dictionary format
+        if not isinstance(info, dict):
+            raise ValueError("info must be a dictionary")
+
+        required_fields = {"user_id", "session_id"}
+        missing_fields = required_fields - set(info.keys())
+        if missing_fields:
+            raise ValueError(f"info dictionary is missing required fields: {missing_fields}")
+
+        if not all(isinstance(info[field], str) for field in required_fields):
+            raise ValueError("user_id and session_id must be strings")
+
+        list_scene_data_info = self.get_scene_data_info(scene_data, type)
+
+        memory_list = []
+
+        if type == "chat":
+            processing_func = self._process_chat_data
+        elif type == "doc":
+            processing_func = self._process_doc_data
+        else:
+            processing_func = self._process_doc_data
+
+        # Process Q&A pairs concurrently
+        with concurrent.futures.ThreadPoolExecutor() as executor:
+            futures = [
+                executor.submit(processing_func, scene_data_info, info)
+                for scene_data_info in list_scene_data_info
+            ]
+            for future in concurrent.futures.as_completed(futures):
+                res_memory = future.result()
+                memory_list.append(res_memory)
+
+        return memory_list
+
+    def get_scene_data_info(self, scene_data: list, type: str) -> list[str]:
+        """
+        Get raw information from scene_data.
+        If scene_data contains dictionaries, convert them to strings.
+        If scene_data contains file paths, parse them using the parser.
+
+        Args:
+            scene_data: List of dialogue information or document paths
+            type: Type of scene data: ['doc', 'chat']
+        Returns:
+            List of strings containing the processed scene data
+        """
+        results = []
+        parser_config = ParserConfigFactory.model_validate(
+            {
+                "backend": "markitdown",
+                "config": {},
+            }
+        )
+        parser = ParserFactory.from_config(parser_config)
+
+        if type == "chat":
+            for items in scene_data:
+                result = []
+                for item in items:
+                    # Convert dictionary to string
+                    if "chat_time" in item:
+                        mem = item["role"] + ": " + f"[{item['chat_time']}]: " + item["content"]
+                        result.append(mem)
+                    else:
+                        mem = item["role"] + ":" + item["content"]
+                        result.append(mem)
+                    if len(result) >= 10:
+                        results.append(result)
+                        context = copy.deepcopy(result[-2:])
+                        result = context
+                if result:
+                    results.append(result)
+        elif type == "doc":
+            for item in scene_data:
+                try:
+                    parsed_text = parser.parse(item)
+                    results.append({"file": item, "text": parsed_text})
+                except Exception as e:
+                    print(f"Error parsing file {item}: {e!s}")
+
+        return results
+
+    def _process_doc_data(self, scene_data_info, info):
+        chunks = self.chunker.chunk(scene_data_info["text"])
+        messages = [
+            [
+                {
+                    "role": "user",
+                    "content": SIMPLE_STRUCT_DOC_READER_PROMPT.replace("{chunk_text}", chunk.text),
+                }
+            ]
+            for chunk in chunks
+        ]
+
+        processed_chunks = []
+        with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:
+            futures = [executor.submit(self.llm.generate, message) for message in messages]
+            for future in concurrent.futures.as_completed(futures):
+                chunk_result = future.result()
+                if chunk_result:
+                    processed_chunks.append(chunk_result)
+
+        processed_chunks = [self.parse_json_result(r) for r in processed_chunks]
+        doc_nodes = []
+        for i, chunk_res in enumerate(processed_chunks):
+            if chunk_res:
+                node_i = TextualMemoryItem(
+                    memory=chunk_res["summary"],
+                    metadata=TreeNodeTextualMemoryMetadata(
+                        user_id=info.get("user_id"),
+                        session_id=info.get("session_id"),
+                        memory_type="LongTermMemory",
+                        status="activated",
+                        tags=chunk_res["tags"],
+                        key="",
+                        embedding=self.embedder.embed([chunk_res["summary"]])[0],
+                        usage=[],
+                        sources=[f"{scene_data_info['file']}_{i}"],
+                        background="",
+                        confidence=0.99,
+                        type="fact",
+                    ),
+                )
+                doc_nodes.append(node_i)
+        return doc_nodes
+
+    def parse_json_result(self, response_text):
+        try:
+            response_text = response_text.replace("```", "").replace("json", "")
+            response_json = json.loads(response_text)
+            return response_json
+        except json.JSONDecodeError as e:
+            logger.warning(
+                f"Failed to parse LLM response as JSON: {e}\nRaw response:\n{response_text}"
+            )
+            return {}
+
+    def transform_memreader(self, data: dict) -> list[TextualMemoryItem]:
+        pass