agentscope-runtime 1.0.5__py3-none-any.whl → 1.1.0b2__py3-none-any.whl

agentscope_runtime/engine/services/memory/mem0_memory_service.py

@@ -1,128 +0,0 @@
-# -*- coding: utf-8 -*-
-import os
-from typing import Optional, Dict, Any, List
-
-from mem0 import AsyncMemoryClient
-
-from .memory_service import MemoryService
-from ...schemas.agent_schemas import Message, MessageType, ContentType
-
-
-class Mem0MemoryService(MemoryService):
-    """
-    Memory service that uses mem0 to store and retrieve memories.
-    To get the api key, please refer to the following link:
-    https://docs.mem0.ai/platform/quickstart
-    """
-
-    def __init__(self, **kwargs):
-        super().__init__(**kwargs)
-        self.service = None
-        self._health = False
-
-    @staticmethod
-    async def get_query_text(message: Message) -> str:
-        """
-        Get the query text from the message.
-        """
-        if message:
-            if message.type == MessageType.MESSAGE:
-                for content in message.content:
-                    if content.type == ContentType.TEXT:
-                        return content.text
-        return ""
-
-    @staticmethod
-    def transform_message(message: Message) -> dict:
-        content_text = None
-
-        try:
-            if hasattr(message, "content") and isinstance(
-                message.content,
-                list,
-            ):
-                if len(message.content) > 0 and hasattr(
-                    message.content[0],
-                    "text",
-                ):
-                    content_text = message.content[0].text
-        except (AttributeError, IndexError):
-            # Log error or handle appropriately
-            pass
-
-        return {
-            "role": getattr(message, "role", None),
-            "content": content_text,
-        }
-
-    async def transform_messages(self, messages: List[Message]) -> List[dict]:
-        return [self.transform_message(message) for message in messages]
-
-    async def start(self):
-        mem0_api_key = os.getenv("MEM0_API_KEY")
-        if mem0_api_key is None:
-            raise ValueError("MEM0_API_KEY is not set")
-        mem0_api_key = os.getenv("MEM0_API_KEY")
-
-        # get the mem0 client instance
-        self.service = AsyncMemoryClient(api_key=mem0_api_key)
-        self._health = True
-
-    async def stop(self):
-        self.service = None
-        self._health = False
-
-    async def health(self):
-        return self._health
-
-    async def add_memory(
-        self,
-        user_id: str,
-        messages: list,
-        session_id: Optional[str] = None,
-    ):
-        messages = await self.transform_messages(messages)
-        return await self.service.add(
-            messages=messages,
-            user_id=user_id,
-            run_id=session_id,
-            # async_mode=True,
-        )
-
-    async def search_memory(
-        self,
-        user_id: str,
-        messages: list,
-        filters: Optional[Dict[str, Any]] = None,
-    ) -> list:
-        query = await self.get_query_text(messages[-1])
-        kwargs = {
-            "query": query,
-            "user_id": user_id,
-        }
-        if filters:
-            kwargs["filters"] = filters
-        return await self.service.search(**kwargs)
-
-    async def list_memory(
-        self,
-        user_id: str,
-        filters: Optional[Dict[str, Any]] = None,
-    ) -> list:
-        kwargs = {"user_id": user_id}
-        if filters:
-            kwargs["filters"] = filters
-        return await self.service.get_all(**kwargs)
-
-    async def delete_memory(
-        self,
-        user_id: str,
-        session_id: Optional[str] = None,
-    ) -> None:
-        if session_id:
-            return await self.service.delete_all(
-                user_id=user_id,
-                run_id=session_id,
-            )
-        else:
-            return await self.service.delete_all(user_id=user_id)

agentscope_runtime/engine/services/memory/memory_service.py

@@ -1,292 +0,0 @@
-# -*- coding: utf-8 -*-
-from abc import abstractmethod
-from typing import Optional, Dict, Any
-
-
-from pydantic import Field
-
-from ..base import ServiceWithLifecycleManager
-from ...schemas.agent_schemas import MessageType, Message
-
-
-class MemoryService(ServiceWithLifecycleManager):
-    """
-    Used to store and retrieve long memory from the database or in-memory.
-    The memory is organized by the user id at top level, under which there are
-    two different memory manage strategies,
-    - one is the message grouped by the session id, the session id is under
-    the user id,
-    - the other is the message grouped by the user id only
-    """
-
-    @abstractmethod
-    async def add_memory(
-        self,
-        user_id: str,
-        messages: list,
-        session_id: Optional[str] = None,
-    ) -> None:
-        """
-        Adds messages to the memory service.
-
-        Args:
-            user_id: The user id.
-            messages: The messages to add.
-            session_id: The session id, which is optional.
-        """
-
-    async def stop(self):
-        raise NotImplementedError
-
-    async def start(self):
-        raise NotImplementedError
-
-    @abstractmethod
-    async def search_memory(
-        self,
-        user_id: str,
-        messages: list,
-        filters: Optional[Dict[str, Any]] = Field(
-            description="Associated filters for the messages, "
-            "such as top_k, score etc.",
-            default=None,
-        ),
-    ) -> list:
-        """
-        Searches messages from the memory service.
-
-        Args:
-            user_id: The user id.
-            messages: The user query or the query with history messages,
-                both in the format of list of messages.  If messages is a list,
-                the search will be based on the content of the last message.
-            filters: The filters used to search memory
-        """
-
-    @abstractmethod
-    async def list_memory(
-        self,
-        user_id: str,
-        filters: Optional[Dict[str, Any]] = Field(
-            description="Associated filters for the messages, "
-            "such as top_k, score etc.",
-            default=None,
-        ),
-    ) -> list:
-        """
-        Lists the memory items for a given user with filters, such as
-        page_num, page_size, etc.
-
-        Args:
-            user_id: The user id.
-            filters: The filters for the memory items.
-        """
-
-    @abstractmethod
-    async def delete_memory(
-        self,
-        user_id: str,
-        session_id: Optional[str] = None,
-    ) -> None:
-        """
-        Deletes the memory items for a given user with certain session id,
-        or all the memory items for a given user.
-        """
-
-
-class InMemoryMemoryService(MemoryService):
-    """
-    An in-memory implementation of the memory service.
-    """
-
-    _DEFAULT_SESSION_ID = "default"
-
-    def __init__(self) -> None:
-        """Initializes the InMemorySessionHistoryService."""
-        self._store: Optional[Dict[str, Dict[str, list]]] = None
-        self._health = False
-
-    async def start(self) -> None:
-        """Initialize the in-memory store."""
-        if self._store is None:
-            self._store = {}
-        self._health = True
-
-    async def stop(self) -> None:
-        """Stops the service."""
-        if self._store is not None:
-            self._store.clear()
-        self._store = None
-        self._health = False
-
-    async def health(self) -> bool:
-        """Checks the health of the service."""
-        return self._health
-
-    async def add_memory(
-        self,
-        user_id: str,
-        messages: list,
-        session_id: Optional[str] = None,
-    ) -> None:
-        """
-        Adds messages to the in-memory store.
-
-        Args:
-            user_id: The user's unique identifier.
-            messages: A list of messages to be added.
-            session_id: An optional session identifier. If not provided,
-            a default session is used.
-        """
-        if self._store is None:
-            raise RuntimeError("Service not started")
-
-        if user_id not in self._store:
-            self._store[user_id] = {}
-
-        storage_key = session_id if session_id else self._DEFAULT_SESSION_ID
-
-        if storage_key not in self._store[user_id]:
-            self._store[user_id][storage_key] = []
-
-        if messages:
-            self._store[user_id][storage_key].extend(messages)
-
-    async def search_memory(
-        self,
-        user_id: str,
-        messages: list,
-        filters: Optional[Dict[str, Any]] = None,
-    ) -> list:
-        """
-        Searches messages from the in-memory store for a specific user
-            based on keywords.
-
-        Args:
-            user_id: The user's unique identifier.
-            messages: A list of messages, where the last message's content
-                is used as the search query.
-            filters: Optional filters to apply, such as 'top_k' to limit the
-                number of returned messages.
-
-        Returns:
-            A list of matching messages from the store.
-        """
-        if self._store is None:
-            raise RuntimeError("Service not started")
-
-        if user_id not in self._store:
-            return []
-
-        if (
-            not messages
-            or not isinstance(messages, list)
-            or len(messages) == 0
-        ):
-            return []
-
-        message = messages[-1]
-        query = await self.get_query_text(message)
-        if not query:
-            return []
-
-        keywords = set(query.lower().split())
-
-        all_messages = []
-        for session_messages in self._store[user_id].values():
-            all_messages.extend(session_messages)
-
-        matched_messages = []
-        for msg in all_messages:
-            candidate_content = await self.get_query_text(msg)
-            if candidate_content:
-                msg_content_lower = candidate_content.lower()
-                if any(keyword in msg_content_lower for keyword in keywords):
-                    matched_messages.append(msg)
-
-        if (
-            filters
-            and "top_k" in filters
-            and isinstance(filters["top_k"], int)
-        ):
-            return matched_messages[-filters["top_k"] :]
-
-        return matched_messages
-
-    async def get_query_text(self, message: Message) -> str:
-        """
-        Gets the query text from the messages.
-
-        Args:
-            message: A list of messages.
-
-        Returns:
-            The query text.
-        """
-        if message:
-            if message.type == MessageType.MESSAGE:
-                for content in message.content:
-                    if content.type == "text":
-                        return content.text
-        return ""
-
-    async def list_memory(
-        self,
-        user_id: str,
-        filters: Optional[Dict[str, Any]] = None,
-    ) -> list:
-        """
-        Lists messages from the in-memory store with pagination support.
-
-        Args:
-            user_id: The user's unique identifier.
-            filters: Optional filters for pagination, including 'page_num'
-                and 'page_size'.
-
-        Returns:
-            A paginated list of messages.
-        """
-        if self._store is None:
-            raise RuntimeError("Service not started")
-
-        if user_id not in self._store:
-            return []
-
-        all_messages = []
-        # Sort by session id to have a consistent order for pagination
-        for session_id in sorted(self._store[user_id].keys()):
-            all_messages.extend(self._store[user_id][session_id])
-
-        page_num = filters.get("page_num", 1) if filters else 1
-        page_size = filters.get("page_size", 10) if filters else 10
-
-        start_index = (page_num - 1) * page_size
-        end_index = start_index + page_size
-
-        return all_messages[start_index:end_index]
-
-    async def delete_memory(
-        self,
-        user_id: str,
-        session_id: Optional[str] = None,
-    ) -> None:
-        """
-        Deletes messages from the in-memory store.
-
-        Args:
-            user_id: The user's unique identifier.
-            session_id: If provided, only deletes the messages for that
-                session. Otherwise, deletes all messages for the user.
-        """
-        if self._store is None:
-            raise RuntimeError("Service not started")
-
-        if user_id not in self._store:
-            return
-
-        if session_id:
-            if session_id in self._store[user_id]:
-                del self._store[user_id][session_id]
-        else:
-            if user_id in self._store:
-                del self._store[user_id]

agentscope_runtime/engine/services/memory/memory_service_factory.py

@@ -1,126 +0,0 @@
-# -*- coding: utf-8 -*-
-
-from typing import Callable, Dict
-
-from ..service_factory import ServiceFactory
-from .memory_service import MemoryService, InMemoryMemoryService
-from .redis_memory_service import RedisMemoryService
-from .mem0_memory_service import Mem0MemoryService
-from .reme_personal_memory_service import ReMePersonalMemoryService
-from .reme_task_memory_service import ReMeTaskMemoryService
-
-try:
-    from .tablestore_memory_service import (
-        TablestoreMemoryService,
-        SearchStrategy,
-    )
-
-    TABLESTORE_AVAILABLE = True
-except ImportError:
-    TABLESTORE_AVAILABLE = False
-    SearchStrategy = None  # type: ignore
-
-
-class MemoryServiceFactory(ServiceFactory[MemoryService]):
-    """
-    Factory for MemoryService, supporting both environment variables and
-    kwargs.
-
-    Usage examples:
-        1. Startup using only environment variables:
-            export MEMORY_BACKEND=redis
-            export MEMORY_REDIS_REDIS_URL="redis://localhost:6379/5"
-            service = await MemoryServiceFactory.create()
-
-        2. Override environment variables using arguments:
-            export MEMORY_BACKEND=redis
-            export MEMORY_REDIS_REDIS_URL="redis://localhost:6379/5"
-            service = await MemoryServiceFactory.create(
-                redis_url="redis://otherhost:6379/1"
-            )
-
-        3. Register a custom backend:
-            from my_backend import PostgresMemoryService
-            MemoryServiceFactory.register_backend(
-                "postgres",
-                PostgresMemoryService,
-            )
-            export MEMORY_BACKEND=postgres
-            export MEMORY_POSTGRES_DSN="postgresql://user:pass@localhost/db"
-            service = await MemoryServiceFactory.create()
-    """
-
-    _registry: Dict[str, Callable[..., MemoryService]] = {}
-    _env_prefix = "MEMORY_"
-    _default_backend = "in_memory"
-
-
-# === Default built-in backend registration ===
-
-MemoryServiceFactory.register_backend(
-    "in_memory",
-    lambda **kwargs: InMemoryMemoryService(),
-)
-
-MemoryServiceFactory.register_backend(
-    "redis",
-    RedisMemoryService,
-)
-
-MemoryServiceFactory.register_backend(
-    "mem0",
-    Mem0MemoryService,
-)
-
-MemoryServiceFactory.register_backend(
-    "reme_personal",
-    ReMePersonalMemoryService,
-)
-
-MemoryServiceFactory.register_backend(
-    "reme_task",
-    ReMeTaskMemoryService,
-)
-
-if TABLESTORE_AVAILABLE:
-
-    def _create_tablestore_memory_service(**kwargs):
-        """Helper function to create a TablestoreMemoryService instance."""
-        search_strategy = kwargs.get("search_strategy")
-        if isinstance(search_strategy, str):
-            search_strategy = SearchStrategy(search_strategy.lower())
-        elif search_strategy is None:
-            search_strategy = SearchStrategy.FULL_TEXT
-
-        return TablestoreMemoryService(
-            tablestore_client=kwargs["tablestore_client"],
-            search_strategy=search_strategy,
-            embedding_model=kwargs.get("embedding_model"),
-            vector_dimension=int(kwargs.get("vector_dimension", 1536)),
-            table_name=kwargs.get("table_name", "agentscope_runtime_memory"),
-            search_index_schema=kwargs.get("search_index_schema"),
-            text_field=kwargs.get("text_field", "text"),
-            embedding_field=kwargs.get("embedding_field", "embedding"),
-            vector_metric_type=kwargs.get("vector_metric_type"),
-            **{
-                k: v
-                for k, v in kwargs.items()
-                if k
-                not in [
-                    "tablestore_client",
-                    "search_strategy",
-                    "embedding_model",
-                    "vector_dimension",
-                    "table_name",
-                    "search_index_schema",
-                    "text_field",
-                    "embedding_field",
-                    "vector_metric_type",
-                ]
-            },
-        )
-
-    MemoryServiceFactory.register_backend(
-        "tablestore",
-        _create_tablestore_memory_service,
-    )