reme-ai 0.1.0__py3-none-any.whl

reme_ai/__init__.py

@@ -0,0 +1,6 @@
+from reme_ai import react
+from reme_ai import retrieve
+from reme_ai import summary
+from reme_ai import vector_store
+
+__version__ = "0.1.0"

reme_ai/app.py

@@ -0,0 +1,17 @@
+import sys
+
+from flowllm.service.base_service import BaseService
+
+from reme_ai.config.config_parser import ConfigParser
+
+
+def main():
+    with BaseService.get_service(*sys.argv[1:], parser=ConfigParser) as service:
+        service()
+
+
+if __name__ == "__main__":
+    main()
+
+# python -m build
+# twine upload dist/*

reme_ai/config/config_parser.py

@@ -0,0 +1,6 @@
+from flowllm.config.pydantic_config_parser import PydanticConfigParser
+
+
+class ConfigParser(PydanticConfigParser):
+    current_file: str = __file__
+    default_config_name: str = "default"

reme_ai/constants/__init__.py

@@ -0,0 +1,7 @@
+from . import common_constants
+from . import language_constants
+
+__all__ = [
+    "common_constants",
+    "language_constants"
+]

reme_ai/constants/common_constants.py

@@ -0,0 +1,48 @@
+# common_constants.py
+# This module defines constants used as keys throughout the application to maintain a consistent reference
+# for data structures related to workflow management, chat interactions, context storage, memory operations,
+# node processing, and temporal inference functionalities.
+
+WORKFLOW_NAME = "workflow_name"
+
+MEMORYSCOPE_CONTEXT = "memoryscope_context"
+
+RESULT = "result"
+
+MEMORIES = "memories"
+
+CHAT_MESSAGES = "chat_messages"
+
+CHAT_MESSAGES_SCATTER = "chat_messages_scatter"
+
+CHAT_KWARGS = "chat_kwargs"
+
+USER_NAME = "user_name"
+
+TARGET_NAME = "target_name"
+
+MEMORY_MANAGER = "memory_manager"
+
+QUERY_WITH_TS = "query_with_ts"
+
+RETRIEVE_MEMORY_NODES = "retrieve_memory_nodes"
+
+RANKED_MEMORY_NODES = "ranked_memory_nodes"
+
+NOT_REFLECTED_NODES = "not_reflected_nodes"
+
+NOT_UPDATED_NODES = "not_updated_nodes"
+
+EXTRACT_TIME_DICT = "extract_time_dict"
+
+NEW_OBS_NODES = "new_obs_nodes"
+
+NEW_OBS_WITH_TIME_NODES = "new_obs_with_time_nodes"
+
+INSIGHT_NODES = "insight_nodes"
+
+TODAY_NODES = "today_nodes"
+
+MERGE_OBS_NODES = "merge_obs_nodes"
+
+TIME_INFER = "time_infer"

reme_ai/constants/language_constants.py

@@ -0,0 +1,215 @@
+from memoryscope.enumeration.language_enum import LanguageEnum
+
+# This dictionary maps languages to lists of words related to datetime expressions.
+# It aids in recognizing and processing datetime mentions in text, enhancing the system's ability to understand
+# temporal context across different languages.
+DATATIME_WORD_LIST = {
+    LanguageEnum.CN: [
+        "天",
+        "周",
+        "月",
+        "年",
+        "星期",
+        "点",
+        "分钟",
+        "小时",
+        "秒",
+        "上午",
+        "下午",
+        "早上",
+        "早晨",
+        "晚上",
+        "中午",
+        "日",
+        "夜",
+        "清晨",
+        "傍晚",
+        "凌晨",
+        "岁",
+    ],
+    LanguageEnum.EN: [
+        # Units of Time
+        "year", "yr",
+        "month", "mo",
+        "week", "wk",
+        "day", "d",
+        "hour", "hr",
+        "minute", "min",
+        "second", "sec",
+
+        # Days of the Week
+        "Monday", "Mon",
+        "Tuesday", "Tue", "Tues",
+        "Wednesday", "Wed",
+        "Thursday", "Thu", "Thur", "Thurs",
+        "Friday", "Fri",
+        "Saturday", "Sat",
+        "Sunday", "Sun",
+
+        # Months of the Year
+        "January", "Jan",
+        "February", "Feb",
+        "March", "Mar",
+        "April", "Apr",
+        "May", "May",
+        "June", "Jun",
+        "July", "Jul",
+        "August", "Aug",
+        "September", "Sep", "Sept",
+        "October", "Oct",
+        "November", "Nov",
+        "December", "Dec",
+
+        # Relative Time References
+        "Today",
+        "Tomorrow", "Tmrw",
+        "Yesterday", "Yday",
+        "Now",
+        "Morning", "AM", "a.m.",
+        "Afternoon", "PM", "p.m.",
+        "Evening",
+        "Night",
+        "Midnight",
+        "Noon",
+
+        # Seasonal References
+        "Spring",
+        "Summer",
+        "Autumn", "Fall",
+        "Winter",
+
+        # General Time References
+        "Century", "cent.",
+        "Decade",
+        "Millennium",
+        "Quarter", "Q1", "Q2", "Q3", "Q4",
+        "Semester",
+        "Fortnight",
+        "Weekend"
+    ]
+}
+
+# A mapping of weekdays for each supported language, facilitating calendar-related operations and understanding
+# within the application.
+WEEKDAYS = {
+    LanguageEnum.CN: [
+        "周一",
+        "周二",
+        "周三",
+        "周四",
+        "周五",
+        "周六",
+        "周日"
+    ],
+    LanguageEnum.EN: [
+        "Monday",
+        "Tuesday",
+        "Wednesday",
+        "Thursday",
+        "Friday",
+        "Saturday",
+        "Sunday",
+    ]
+}
+
+MONTH_DICT = {
+    LanguageEnum.CN: [
+        "1月",
+        "2月",
+        "3月",
+        "4月",
+        "5月",
+        "6月",
+        "7月",
+        "8月",
+        "9月",
+        "10月",
+        "11月",
+        "12月",
+    ],
+    LanguageEnum.EN: [
+        "January",
+        "February",
+        "March",
+        "April",
+        "May",
+        "June",
+        "July",
+        "August",
+        "September",
+        "October",
+        "November",
+        "December",
+    ]
+}
+
+# Constants for the word 'none' in different languages
+NONE_WORD = {
+    LanguageEnum.CN: "无",
+    LanguageEnum.EN: "none"
+}
+
+# Constants for the word 'repeated' in different languages
+REPEATED_WORD = {
+    LanguageEnum.CN: "重复",
+    LanguageEnum.EN: "repeated"
+}
+
+# Constants for the word 'contradictory' in different languages
+CONTRADICTORY_WORD = {
+    LanguageEnum.CN: "矛盾",
+    LanguageEnum.EN: "contradiction"
+}
+
+# Constants for the phrase 'included' in different languages
+CONTAINED_WORD = {
+    LanguageEnum.CN: "被包含",
+    LanguageEnum.EN: "contained"
+}
+
+# Constants for the symbol ':' in different languages' representations
+COLON_WORD = {
+    LanguageEnum.CN: "：",
+    LanguageEnum.EN: ":"
+}
+
+# Constants for the symbol ',' in different languages' representations
+COMMA_WORD = {
+    LanguageEnum.CN: "，",
+    LanguageEnum.EN: ","
+}
+
+# Default human name placeholders for different languages
+DEFAULT_HUMAN_NAME = {
+    LanguageEnum.CN: "用户",
+    LanguageEnum.EN: "user"
+}
+
+# Mapping of datetime terms from natural language to standardized keys for each supported language
+DATATIME_KEY_MAP = {
+    LanguageEnum.CN: {
+        "年": "year",
+        "月": "month",
+        "日": "day",
+        "周": "week",
+        "星期几": "weekday",
+    },
+    LanguageEnum.EN: {
+        "Year": "year",
+        "Month": "month",
+        "Day": "day",
+        "Week": "week",
+        "Weekday": "weekday",
+    }
+}
+
+# Phrase for indicating inferred time in different languages
+TIME_INFER_WORD = {
+    LanguageEnum.CN: "推断时间",
+    LanguageEnum.EN: "Inference time"
+}
+
+USER_NAME_EXPRESSION = {
+    LanguageEnum.CN: "用户姓名是{name}。",
+    LanguageEnum.EN: "User's name is {name}."
+}

reme_ai/enumeration/language_constants.py

@@ -0,0 +1,215 @@
+from memoryscope.enumeration.language_enum import LanguageEnum
+
+# This dictionary maps languages to lists of words related to datetime expressions.
+# It aids in recognizing and processing datetime mentions in text, enhancing the system's ability to understand
+# temporal context across different languages.
+DATATIME_WORD_LIST = {
+    LanguageEnum.CN: [
+        "天",
+        "周",
+        "月",
+        "年",
+        "星期",
+        "点",
+        "分钟",
+        "小时",
+        "秒",
+        "上午",
+        "下午",
+        "早上",
+        "早晨",
+        "晚上",
+        "中午",
+        "日",
+        "夜",
+        "清晨",
+        "傍晚",
+        "凌晨",
+        "岁",
+    ],
+    LanguageEnum.EN: [
+        # Units of Time
+        "year", "yr",
+        "month", "mo",
+        "week", "wk",
+        "day", "d",
+        "hour", "hr",
+        "minute", "min",
+        "second", "sec",
+
+        # Days of the Week
+        "Monday", "Mon",
+        "Tuesday", "Tue", "Tues",
+        "Wednesday", "Wed",
+        "Thursday", "Thu", "Thur", "Thurs",
+        "Friday", "Fri",
+        "Saturday", "Sat",
+        "Sunday", "Sun",
+
+        # Months of the Year
+        "January", "Jan",
+        "February", "Feb",
+        "March", "Mar",
+        "April", "Apr",
+        "May", "May",
+        "June", "Jun",
+        "July", "Jul",
+        "August", "Aug",
+        "September", "Sep", "Sept",
+        "October", "Oct",
+        "November", "Nov",
+        "December", "Dec",
+
+        # Relative Time References
+        "Today",
+        "Tomorrow", "Tmrw",
+        "Yesterday", "Yday",
+        "Now",
+        "Morning", "AM", "a.m.",
+        "Afternoon", "PM", "p.m.",
+        "Evening",
+        "Night",
+        "Midnight",
+        "Noon",
+
+        # Seasonal References
+        "Spring",
+        "Summer",
+        "Autumn", "Fall",
+        "Winter",
+
+        # General Time References
+        "Century", "cent.",
+        "Decade",
+        "Millennium",
+        "Quarter", "Q1", "Q2", "Q3", "Q4",
+        "Semester",
+        "Fortnight",
+        "Weekend"
+    ]
+}
+
+# A mapping of weekdays for each supported language, facilitating calendar-related operations and understanding
+# within the application.
+WEEKDAYS = {
+    LanguageEnum.CN: [
+        "周一",
+        "周二",
+        "周三",
+        "周四",
+        "周五",
+        "周六",
+        "周日"
+    ],
+    LanguageEnum.EN: [
+        "Monday",
+        "Tuesday",
+        "Wednesday",
+        "Thursday",
+        "Friday",
+        "Saturday",
+        "Sunday",
+    ]
+}
+
+MONTH_DICT = {
+    LanguageEnum.CN: [
+        "1月",
+        "2月",
+        "3月",
+        "4月",
+        "5月",
+        "6月",
+        "7月",
+        "8月",
+        "9月",
+        "10月",
+        "11月",
+        "12月",
+    ],
+    LanguageEnum.EN: [
+        "January",
+        "February",
+        "March",
+        "April",
+        "May",
+        "June",
+        "July",
+        "August",
+        "September",
+        "October",
+        "November",
+        "December",
+    ]
+}
+
+# Constants for the word 'none' in different languages
+NONE_WORD = {
+    LanguageEnum.CN: "无",
+    LanguageEnum.EN: "none"
+}
+
+# Constants for the word 'repeated' in different languages
+REPEATED_WORD = {
+    LanguageEnum.CN: "重复",
+    LanguageEnum.EN: "repeated"
+}
+
+# Constants for the word 'contradictory' in different languages
+CONTRADICTORY_WORD = {
+    LanguageEnum.CN: "矛盾",
+    LanguageEnum.EN: "contradiction"
+}
+
+# Constants for the phrase 'included' in different languages
+CONTAINED_WORD = {
+    LanguageEnum.CN: "被包含",
+    LanguageEnum.EN: "contained"
+}
+
+# Constants for the symbol ':' in different languages' representations
+COLON_WORD = {
+    LanguageEnum.CN: "：",
+    LanguageEnum.EN: ":"
+}
+
+# Constants for the symbol ',' in different languages' representations
+COMMA_WORD = {
+    LanguageEnum.CN: "，",
+    LanguageEnum.EN: ","
+}
+
+# Default human name placeholders for different languages
+DEFAULT_HUMAN_NAME = {
+    LanguageEnum.CN: "用户",
+    LanguageEnum.EN: "user"
+}
+
+# Mapping of datetime terms from natural language to standardized keys for each supported language
+DATATIME_KEY_MAP = {
+    LanguageEnum.CN: {
+        "年": "year",
+        "月": "month",
+        "日": "day",
+        "周": "week",
+        "星期几": "weekday",
+    },
+    LanguageEnum.EN: {
+        "Year": "year",
+        "Month": "month",
+        "Day": "day",
+        "Week": "week",
+        "Weekday": "weekday",
+    }
+}
+
+# Phrase for indicating inferred time in different languages
+TIME_INFER_WORD = {
+    LanguageEnum.CN: "推断时间",
+    LanguageEnum.EN: "Inference time"
+}
+
+USER_NAME_EXPRESSION = {
+    LanguageEnum.CN: "用户姓名是{name}。",
+    LanguageEnum.EN: "User's name is {name}."
+}

reme_ai/react/__init__.py

@@ -0,0 +1 @@
+from .simple_react_op import SimpleReactOp

reme_ai/react/simple_react_op.py

@@ -0,0 +1,21 @@
+from flowllm import C
+from flowllm.context.flow_context import FlowContext
+from flowllm.op.agent.react_v2_op import ReactV2Op
+
+
+@C.register_op()
+class SimpleReactOp(ReactV2Op):
+    ...
+
+
+if __name__ == "__main__":
+    from reme_ai.config.config_parser import ConfigParser
+
+    C.set_default_service_config(parser=ConfigParser).init_by_service_config()
+    context = FlowContext(query="茅台和五粮现在股价多少？")
+
+    op = SimpleReactOp()
+    op(context=context)
+    # from reme_ai.schema import Message
+    # result = op.llm.chat(messages=[Message(**{"role": "user", "content": "你叫什么名字？"})])
+    # print("!!!", result)

reme_ai/retrieve/__init__.py

@@ -0,0 +1,2 @@
+from . import personal
+from . import task

reme_ai/retrieve/personal/__init__.py

@@ -0,0 +1,17 @@
+from .extract_time_op import ExtractTimeOp
+from .fuse_rerank_op import FuseRerankOp
+from .print_memory_op import PrintMemoryOp
+from .read_message_op import ReadMessageOp
+from .retrieve_memory_op import RetrieveMemoryOp
+from .semantic_rank_op import SemanticRankOp
+from .set_query_op import SetQueryOp
+
+__all__ = [
+    "ExtractTimeOp",
+    "FuseRerankOp",
+    "PrintMemoryOp",
+    "ReadMessageOp",
+    "RetrieveMemoryOp",
+    "SemanticRankOp",
+    "SetQueryOp"
+]

reme_ai/retrieve/personal/extract_time_op.py

@@ -0,0 +1,97 @@
+import re
+from typing import Dict
+
+from flowllm import C, BaseLLMOp
+from flowllm.enumeration.role import Role
+from flowllm.schema.message import Message
+from loguru import logger
+
+from reme_ai.constants.common_constants import QUERY_WITH_TS, EXTRACT_TIME_DICT
+from reme_ai.constants.language_constants import DATATIME_KEY_MAP
+from reme_ai.utils.datetime_handler import DatetimeHandler
+
+
+@C.register_op()
+class ExtractTimeOp(BaseLLMOp):
+    file_path: str = __file__
+    EXTRACT_TIME_PATTERN = r"-\s*(\S+)[：:]\s*(\S+)"
+
+    """
+    A specialized worker class designed to identify and extract time-related information
+    from text generated by an LLM, translating date-time keywords based on the set language,
+    and storing this extracted data within a shared context.
+    """
+
+    def get_language_value(self, value_dict: dict):
+
+        return value_dict.get(self.language, value_dict.get("en"))
+
+    def execute(self):
+        """
+        Executes the primary logic of identifying and extracting time data from an LLM's response.
+
+        This method first checks if the input query contains any datetime keywords. If not, it logs and returns.
+        It then constructs a prompt with contextual information including formatted timestamps and calls the LLM.
+        The response is parsed for time-related data using regex, translated via a language-specific key map,
+        and the resulting time data is stored in the shared context.
+        """
+        query, query_timestamp = self.context[QUERY_WITH_TS]
+
+        # Identify if the query contains datetime keywords
+        contain_datetime = DatetimeHandler.has_time_word(query, self.language)
+        if not contain_datetime:
+            logger.info(f"Query contains no datetime keywords: {contain_datetime}")
+            # Set empty time dict for downstream operations
+            self.context[EXTRACT_TIME_DICT] = {}
+            return
+
+        # Prepare the prompt with necessary contextual details
+        time_format = self.prompt_format(prompt_name="time_string_format")
+        query_time_str = DatetimeHandler(dt=query_timestamp).string_format(time_format, self.language)
+
+        # Create message with system and few-shot examples
+        system_prompt = self.prompt_format(prompt_name="extract_time_system")
+        few_shot = self.prompt_format(prompt_name="extract_time_few_shot")
+        user_prompt = self.prompt_format(prompt_name="extract_time_user_query",
+                                         query=query, query_time_str=query_time_str)
+
+        full_prompt = f"{system_prompt}\n\n{few_shot}\n\n{user_prompt}"
+        logger.info(f"Extracting time from query: {query[:100]}...")
+
+        # Invoke the LLM to generate a response
+        response = self.llm.chat([Message(role=Role.USER, content=full_prompt)])
+
+        # Handle empty or unsuccessful responses
+        if not response or not response.content:
+            logger.warning("LLM returned empty response for time extraction")
+            self.context[EXTRACT_TIME_DICT] = {}
+            return
+
+        response_text = response.content
+
+        # Extract and parse time information from the LLM's response
+        extract_time_dict = self._parse_time_from_response(response_text)
+
+        logger.info(f"Extracted time information: {extract_time_dict}")
+        self.context[EXTRACT_TIME_DICT] = extract_time_dict
+
+    def _parse_time_from_response(self, response_text: str) -> Dict[str, str]:
+        """
+        Parse time information from LLM response using regex.
+        
+        Args:
+            response_text: Raw LLM response content
+            
+        Returns:
+            Dictionary of extracted time information
+        """
+        extract_time_dict: Dict[str, str] = {}
+        matches = re.findall(self.EXTRACT_TIME_PATTERN, response_text)
+        key_map: dict = DATATIME_KEY_MAP[DatetimeHandler.language_transform]
+
+        for key, value in matches:
+            if key in key_map.keys():
+                extract_time_dict[key_map[key]] = value
+
+        logger.debug(f"Time extraction - Response: {response_text[:200]}... Matches: {matches}")
+        return extract_time_dict