Add long-term memory feature to Friday

Author: hongxicheng

packages/app/friday/args.py

@@ -63,6 +63,52 @@ def get_args() -> Namespace:
         type=bool,
         required=True,
     )
+    parser.add_argument(
+        "--longTermMemory",
+        type=bool,
+        default=False,
+        help="Whether to enable long-term memory and embedding support.",
+    )
+    parser.add_argument(
+        "--embeddingProvider",
+        type=str,
+        choices=["dashscope", "openai", "gemini", "ollama"],
+        help="Embedding provider name, e.g. openai/dashscope/gemini/ollama.",
+    )
+    parser.add_argument(
+        "--embeddingModelName",
+        type=str,
+        help="Embedding model name, e.g. text-embedding-3-small or text-embedding-v1.",
+    )
+    parser.add_argument(
+        "--embeddingApiKey",
+        type=str,
+        help="API key for the embedding provider; falls back to --apiKey if not set.",
+    )
+    parser.add_argument(
+        "--embeddingKwargs",
+        type=json_type,
+        default={},
+        help="A JSON string for extra kwargs passed to the embedding model (e.g. host, dimensions).",
+    )
+    parser.add_argument(
+        "--saveToLocal",
+        type=bool,
+        default=False,
+        help="Whether to save long-term memory to local disk.",
+    )
+    parser.add_argument(
+        "--localStoragePath",
+        type=str,
+        default="",
+        help="Local storage path for long-term memory.",
+    )
+    parser.add_argument(
+        "--vectorStoreProvider",
+        type=str,
+        default="qdrant",
+        help="Vector store provider for long-term memory (e.g. qdrant, chroma, faiss).",
+    )
     parser.add_argument(
         "--clientKwargs",
         type=json_type,

packages/app/friday/main.py

@@ -8,7 +8,7 @@
 
 import json5
 from agentscope.agent import ReActAgent
-from agentscope.memory import InMemoryMemory
+from agentscope.memory import InMemoryMemory, Mem0LongTermMemory
 from agentscope.message import Msg
 from agentscope.session import JSONSession
 from agentscope.tool import (
@@ -25,7 +25,7 @@
     studio_post_reply_hook,
 )
 from args import get_args
-from model import get_model, get_formatter
+from model import get_model, get_formatter, get_embedding_model, get_memory_model
 from tool.utils import (
     view_agentscope_library,
     view_agentscope_readme,
@@ -36,6 +36,8 @@
 from utils.constants import FRIDAY_SESSION_ID
 
 from mcp_manager import connect_mcp_servers, close_mcp_connections
+from mem0.vector_stores.configs import VectorStoreConfig
+
 
 async def main():
     args = get_args()
@@ -94,13 +96,55 @@ async def main():
     local_mcp_clients = await connect_mcp_servers(mcp_servers, toolkit)
 
     # get model from args
-    model = get_model(args.llmProvider, args.modelName, args.apiKey, args.clientKwargs, args.generateKwargs)
+    model = get_model(
+        args.llmProvider,
+        args.modelName,
+        args.apiKey,
+        args.clientKwargs,
+        args.generateKwargs,
+    )
     formatter = get_formatter(args.llmProvider)
 
-    # Create the ReAct agent
-    agent = ReActAgent(
-        name="Friday",
-        sys_prompt="""You're Friday, a helpful assistant specialized in daily task management and AgentScope framework support.
+    # Initialize long-term memory if enabled
+    long_term_memory = None
+    if args.longTermMemory:
+        memory_model = get_memory_model(
+            args.llmProvider,
+            args.modelName,
+            args.apiKey,
+            args.clientKwargs,
+            args.generateKwargs,
+        )
+        embedding_model = get_embedding_model(
+            embeddingProvider=args.embeddingProvider,
+            embeddingModelName=args.embeddingModelName,
+            embeddingApiKey=args.embeddingApiKey,
+            embedding_kwargs=args.embeddingKwargs,
+        )
+
+        # Prepare vector store config with embedding dimensions
+        vector_store_config_dict = {
+            "on_disk": args.saveToLocal,
+            "path": args.localStoragePath,
+        }
+
+        # Add embedding_model_dims for vector stores that need it (e.g., Qdrant)
+        if hasattr(embedding_model, 'dimensions'):
+            vector_store_config_dict["embedding_model_dims"] = embedding_model.dimensions
+
+        long_term_memory = Mem0LongTermMemory(
+            agent_name="Friday",
+            user_name="Studio",
+            model=memory_model,
+            embedding_model=embedding_model,
+            vector_store_config=VectorStoreConfig(
+                provider=args.vectorStoreProvider,
+                config=vector_store_config_dict,
+            ),
+        )
+
+    # Build system prompt
+    sys_prompt = """You're Friday, a helpful assistant specialized in daily task management and AgentScope framework support.
 
 # Core Objectives
 - Help users manage and complete daily tasks efficiently
@@ -130,7 +174,21 @@ async def main():
 - Never guess or make up implementations
 
 # Available Context
-- Current date and time: {current_time}""".format(
+- Current date and time: {current_time}"""
+
+    # Add long-term memory information if enabled
+    if args.longTermMemory:
+        sys_prompt += """
+
+# Long-term Memory
+- You have long-term memory enabled, which allows you to remember information across conversations
+- Use this capability to provide more personalized and context-aware assistance
+- You can reference past interactions and learned preferences to better serve the user"""
+
+    # Create the ReAct agent
+    agent = ReActAgent(
+        name="Friday",
+        sys_prompt=sys_prompt.format(
             current_time=datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
             max_turns=20,
         ),
@@ -140,6 +198,8 @@ async def main():
         memory=InMemoryMemory(),
         max_iters=50,
         enable_meta_tool=True,
+        long_term_memory=long_term_memory,
+        long_term_memory_mode='both'
     )
 
     path_dialog_history = get_local_file_path("")

packages/app/friday/model.py

@@ -1,6 +1,7 @@
 # -*- coding: utf-8 -*-
 """Get the formatter and model based on the model provider."""
 import re
+
 import agentscope
 from agentscope.formatter import (
     DashScopeChatFormatter,
@@ -18,24 +19,24 @@
     GeminiChatModel,
     AnthropicChatModel,
 )
+from agentscope.embedding import (
+    EmbeddingModelBase,
+    EmbeddingUsage,
+    EmbeddingResponse,
+    DashScopeTextEmbedding,
+    DashScopeMultiModalEmbedding,
+    OpenAITextEmbedding,
+    GeminiTextEmbedding,
+    OllamaTextEmbedding,
+    EmbeddingCacheBase,
+    FileEmbeddingCache,
+)
 
 
 def is_agentscope_version_ge(target_version: tuple) -> bool:
-    """
-    Check if the current agentscope version is greater than or equal to the target version.
-
-    Args:
-        target_version: A tuple of (major, minor, patch) version numbers.
-
-    Returns:
-        True if current version >= target version, False otherwise.
-
-    Example:
-        >>> is_agentscope_version_ge((1, 0, 9))  # Works with "1.0.9" or "1.0.9dev"
-        True
-    """
+    """Check whether the current agentscope version is >= target_version."""
     version_str = agentscope.__version__
-    version_match = re.match(r'^(\d+)\.(\d+)\.(\d+)', version_str)
+    version_match = re.match(r"^(\d+)\.(\d+)\.(\d+)", version_str)
     if version_match:
         major, minor, patch = map(int, version_match.groups())
         current_version = (major, minor, patch)
@@ -61,14 +62,15 @@ def get_formatter(llmProvider: str) -> FormatterBase:
                 f"Unsupported model provider: {llmProvider}. "
             )
 
+
 def get_model(
     llmProvider: str,
     modelName: str,
     apiKey: str,
     client_kwargs: dict = {},
     generate_kwargs: dict = {},
 ) -> ChatModelBase:
-    """Get the model instance based on the input arguments."""
+    """Get the chat model instance based on the input arguments."""
 
     match llmProvider.lower():
         case "dashscope":
@@ -122,3 +124,112 @@ def get_model(
             raise ValueError(
                 f"Unsupported model provider: {llmProvider}. "
             )
+
+def get_memory_model(
+    llmProvider: str,
+    modelName: str,
+    apiKey: str,
+    client_kwargs: dict = {},
+    generate_kwargs: dict = {},
+) -> ChatModelBase:
+    """Get the chat model instance based on the input arguments."""
+
+    match llmProvider.lower():
+        case "dashscope":
+            return DashScopeChatModel(
+                model_name=modelName,
+                api_key=apiKey,
+                stream=False,
+                generate_kwargs=generate_kwargs,
+            )
+        case "openai":
+            return OpenAIChatModel(
+                model_name=modelName,
+                api_key=apiKey,
+                stream=False,
+                client_kwargs=client_kwargs,
+                generate_kwargs=generate_kwargs,
+            )
+        case "ollama":
+            if is_agentscope_version_ge((1, 0, 9)):
+                # For agentscope >= 1.0.9
+                return OllamaChatModel(
+                    model_name=modelName,
+                    stream=False,
+                    client_kwargs=client_kwargs,
+                    generate_kwargs=generate_kwargs,
+                )
+            else:
+                # For agentscope < 1.0.9
+                return OllamaChatModel(
+                    model_name=modelName,
+                    stream=False,
+                    **client_kwargs,
+                )
+        case "gemini":
+            return GeminiChatModel(
+                model_name=modelName,
+                api_key=apiKey,
+                stream=False,
+                client_kwargs=client_kwargs,
+                generate_kwargs=generate_kwargs,
+            )
+        case "anthropic":
+            return AnthropicChatModel(
+                model_name=modelName,
+                api_key=apiKey,
+                stream=False,
+                client_kwargs=client_kwargs,
+                generate_kwargs=generate_kwargs,
+            )
+        case _:
+            raise ValueError(
+                f"Unsupported model provider: {llmProvider}. "
+            )
+
+
+def get_embedding_model(
+    embeddingProvider: str,
+    embeddingModelName: str,
+    embeddingApiKey: str,
+    embedding_kwargs: dict = {},
+) -> EmbeddingModelBase:
+    """Get the embedding model instance based on the input arguments.
+
+    The signature follows the corresponding classes in ``agentscope.embedding``.
+    ``embedding_kwargs`` can be used to pass extra provider-specific keyword
+    arguments, such as ``host`` or ``dimensions``.
+    """
+
+    match embeddingProvider.lower():
+        case "dashscope":
+            # DashScopeTextEmbedding(model_name: str, api_key: str, **kwargs)
+            return DashScopeTextEmbedding(
+                model_name=embeddingModelName,
+                api_key=embeddingApiKey,
+                **embedding_kwargs,
+            )
+        case "openai":
+            # OpenAITextEmbedding(model_name: str, api_key: str, **kwargs)
+            return OpenAITextEmbedding(
+                model_name=embeddingModelName,
+                api_key=embeddingApiKey,
+                **embedding_kwargs,
+            )
+        case "gemini":
+            # GeminiTextEmbedding(model_name: str, api_key: str, **kwargs)
+            return GeminiTextEmbedding(
+                model_name=embeddingModelName,
+                api_key=embeddingApiKey,
+                **embedding_kwargs,
+            )
+        case "ollama":
+            # OllamaTextEmbedding(model_name: str, **kwargs)
+            return OllamaTextEmbedding(
+                model_name=embeddingModelName,
+                **embedding_kwargs,
+            )
+        case _:
+            raise ValueError(
+                f"Unsupported embedding provider: {embeddingProvider}. "
+            )

packages/app/friday/utils/common.py

@@ -2,6 +2,7 @@
 """Utility functions for file path management in AgentScope Studio."""
 import platform
 import os
+import shutil
 
 from utils.constants import NAME_STUDIO, NAME_APP
 
@@ -26,3 +27,31 @@ def get_local_file_path(filename: str) -> str:
         os.makedirs(os.path.join(local_path, NAME_APP), exist_ok=True)
 
     return os.path.join(local_path, NAME_APP, filename)
+
+
+def clear_vector_store(storage_path: str, provider: str = "qdrant") -> None:
+    """Clear the vector store data to resolve dimension mismatch issues.
+    
+    Args:
+        storage_path: The base path where vector store data is saved
+        provider: The vector store provider name (default: qdrant)
+    """
+    if not storage_path:
+        # Use default path if not specified
+        storage_path = get_local_file_path("")
+    
+    # Construct vector store path based on provider
+    if provider.lower() == "qdrant":
+        vector_store_path = os.path.join(storage_path, "qdrant_storage")
+    elif provider.lower() == "chroma":
+        vector_store_path = os.path.join(storage_path, "chroma_db")
+    else:
+        # For other providers, use a generic folder name
+        vector_store_path = os.path.join(storage_path, f"{provider}_storage")
+    
+    # Remove the vector store directory if it exists
+    if os.path.exists(vector_store_path):
+        print(f"Clearing vector store at: {vector_store_path}")
+        shutil.rmtree(vector_store_path)
+        print("Vector store cleared successfully")
+