Merge pull request #192 from helloissariel/main

Mem0

Author: moonpyt

examples/mem0_agent_demo.py

@@ -0,0 +1,83 @@
+"""Mem0 long-term memory demo: The Intelligent Web3 Portfolio Assistant"""
+
+import asyncio
+import os
+from typing import List
+
+from spoon_ai.chat import ChatBot
+
+USER_ID = "crypto_whale_001"
+SYSTEM_PROMPT = (
+    "You are the Intelligent Web3 Portfolio Assistant. "
+    "Remember user risk appetite, preferred chains, and asset types. "
+    "Recommend actionable strategies without re-asking for already stored preferences."
+)
+
+
+def new_llm(mem0_config: dict) -> ChatBot:
+    """Create a new ChatBot configured for long-term memory with Mem0."""
+    return ChatBot(
+        llm_provider="openrouter",
+        model_name="openai/gpt-5.1", 
+        enable_long_term_memory=True,
+        mem0_config=mem0_config,
+    )
+
+
+def print_memories(memories: List[str], label: str) -> None:
+    print(f"[Mem0] {label}:")
+    for m in memories:
+        print(f"  - {m}")
+
+
+async def main() -> None:
+    mem0_config = {
+        "user_id": USER_ID,
+        "metadata": {"project": "web3-portfolio-assistant"},
+        "async_mode": False,  # synchronous writes so retrieval in the next turn works immediately
+    }
+
+    # Step 1: Introduction / preference capture
+    print(" Session 1: Capturing preferences")
+    llm = new_llm(mem0_config)
+    first_reply = await llm.ask(
+        [{"role": "user", "content": (
+        "I am a high-risk degen trader. I exclusively trade meme coins on the Solana blockchain. "
+        "I hate Ethereum gas fees.")}],
+        system_msg=SYSTEM_PROMPT,
+    )
+    print("First reply:", first_reply)
+
+    memories = llm.mem0_client.search_memory("Solana meme coins high risk")
+    print_memories(memories, "After Session 1")
+
+    # Step 2: Recall after re-initialization
+    print(" Session 2: Recall with a brand new agent instance")
+    llm_reloaded = new_llm(mem0_config)
+    second_reply = await llm_reloaded.ask(
+        [{"role": "user", "content": "Recommend a trading strategy for me today."}],
+        system_msg=SYSTEM_PROMPT,
+    )
+    print("Second reply:", second_reply)
+
+    memories = llm_reloaded.mem0_client.search_memory("trading strategy solana meme")
+    print_memories(memories, "Retrieved for Session 2")
+
+
+    # Step 3: Update preferences and verify recency/relevance
+    print(" Session 3: Updating preferences to safer Arbitrum yield")
+    third_reply = await llm_reloaded.ask(
+        [{"role": "user", "content": "I lost too much money. I want to pivot to safe stablecoin yield farming on Arbitrum now."}],
+        system_msg=SYSTEM_PROMPT,
+    )
+    print("Third reply:", third_reply)
+    fourth_reply = await llm_reloaded.ask(
+        [{"role": "user", "content": "What chain should I use?"}],
+        system_msg=SYSTEM_PROMPT,
+    )
+    print("Fourth reply:", fourth_reply)
+    memories = llm_reloaded.mem0_client.search_memory("stablecoin yield chain choice")
+    print_memories(memories, "Retrieved after update (Session 3)")
+
+if __name__ == "__main__":
+    asyncio.run(main())

examples/mem0_tool_agent.py

@@ -0,0 +1,136 @@
+"""
+Mem0 toolkit demo using SpoonReactAI.
+This demo requires spoon-toolkit to be installed
+"""
+
+import asyncio
+from typing import Any, Dict, List
+
+from pydantic import Field
+
+from spoon_ai.agents.spoon_react import SpoonReactAI
+from spoon_ai.chat import ChatBot
+from spoon_ai.tools.tool_manager import ToolManager
+from spoon_ai.tools.base import ToolResult
+from spoon_toolkits.memory import AddMemoryTool, SearchMemoryTool, GetAllMemoryTool
+
+
+USER_ID = "defi_user_002"
+
+
+class DeFiMemoryAgent(SpoonReactAI):
+    """Brain from spoon-core + memory tools from spoon-toolkit."""
+
+    mem0_config: Dict[str, Any] = Field(default_factory=dict)
+    available_tools: ToolManager = Field(default_factory=lambda: ToolManager([]))
+
+    def model_post_init(self, __context: Any = None) -> None:
+        super().model_post_init(__context)
+        # Rebuild tools with the injected mem0_config for this agent
+        memory_tools = [
+            AddMemoryTool(mem0_config=self.mem0_config),
+            SearchMemoryTool(mem0_config=self.mem0_config),
+            GetAllMemoryTool(mem0_config=self.mem0_config),
+        ]
+        self.available_tools = ToolManager(memory_tools)
+        # Refresh prompts so SpoonReactAI lists the newly provided tools
+        if hasattr(self, "_refresh_prompts"):
+            self._refresh_prompts()
+
+
+def build_agent(mem0_cfg: Dict[str, Any]) -> DeFiMemoryAgent:
+    return DeFiMemoryAgent(
+        llm=ChatBot(
+            llm_provider="openrouter",
+            base_url="https://openrouter.ai/api/v1",
+            model_name="anthropic/claude-3.5-sonnet",
+            enable_long_term_memory=False,  # memory comes from toolkit tools instead
+        ),
+        mem0_config=mem0_cfg,
+        system_prompt=(
+            "You are a DeFi investment advisor. Use the provided Mem0 tools to recall "
+            "and update user preferences before answering."
+        ),
+    )
+
+
+def print_memories(result: ToolResult, label: str) -> None:
+    if not isinstance(result, ToolResult):
+        print(f"[Mem0] {label}: error -> {result}")
+        return
+    memories: List[str] = result.output.get("memories", []) if result and result.output else []
+    print(f"[Mem0] {label}:")
+    for m in memories:
+        print(f"  - {m}")
+
+
+async def phase_capture(agent: DeFiMemoryAgent) -> None:
+    print("\n=== Phase 1: Capture high-risk Solana preferences ===")
+    await agent.available_tools.execute(
+        name="add_memory",
+        tool_input={
+            "messages": [
+                {
+                    "role": "user",
+                    "content": (
+                        "I am a high-risk degen trader. I exclusively trade meme coins on Solana "
+                        "and dislike Ethereum gas fees."
+                    ),
+                }
+            ]
+        },
+    )
+    memories = await agent.available_tools.execute(
+        name="search_memory",
+        tool_input={"query": "Solana meme coins high risk"},
+    )
+    print_memories(memories, "After Phase 1 store")
+
+
+async def phase_recall(mem0_cfg: Dict[str, Any]) -> None:
+    print("\n=== Phase 2: Recall with a fresh agent instance ===")
+    agent = build_agent(mem0_cfg)
+    memories = await agent.available_tools.execute(
+        name="search_memory",
+        tool_input={"query": "trading strategy solana meme"},
+    )
+    print_memories(memories, "Retrieved for Phase 2")
+
+
+async def phase_update(agent: DeFiMemoryAgent) -> None:
+    print("\n=== Phase 3: Update preferences to safer Arbitrum yield ===")
+    await agent.available_tools.execute(
+        name="add_memory",
+        tool_input={
+            "messages": [
+                {
+                    "role": "user",
+                    "content": (
+                        "I lost too much money. I want to pivot to safe stablecoin yield farming on Arbitrum now."
+                    ),
+                }
+            ]
+        },
+    )
+    memories = await agent.available_tools.execute(
+        name="search_memory",
+        tool_input={"query": "stablecoin yield chain choice"},
+    )
+    print_memories(memories, "Retrieved after update (Phase 3)")
+
+
+async def main() -> None:
+    mem0_cfg = {
+        "user_id": USER_ID,
+        "metadata": {"project": "defi-investment-advisor"},
+        "async_mode": False,  # synchronous writes so the next search sees new data
+    }
+    agent = build_agent(mem0_cfg)
+    await phase_capture(agent)
+    await phase_recall(mem0_cfg)
+    await phase_update(agent)
+    
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

pyproject.toml

@@ -19,7 +19,7 @@ classifiers = [
 ]
 dependencies = [ # Complete dependencies from requirements.txt for out-of-the-box usage
     "aiohappyeyeballs>=2.4.4",
-    "aiohttp>=3.10.5",
+    "aiohttp>=3.13.2",
     "aiosignal>=1.3.2",
     "annotated-types>=0.7.0",
     "anyio>=4.8.0",
@@ -78,6 +78,11 @@ dependencies = [ # Complete dependencies from requirements.txt for out-of-the-bo
     "x402>=0.2.1",
 ]
 
+[project.optional-dependencies]
+memory = [
+    "mem0ai>=0.0.1",
+]
+
 [project.urls]
 "Homepage" = "https://github.com/XSpoonAi/spoon-core" # Project URL
 "Bug Tracker" = "https://github.com/XSpoonAi/spoon-core/issues" # Project issue tracker URL

requirements.txt

@@ -6,7 +6,7 @@
 #
 aiohappyeyeballs>=2.4.4
     # via aiohttp
-aiohttp==3.10.5
+aiohttp>=3.13.2
 aiosignal>=1.3.2
     # via aiohttp
 annotated-types>=0.7.0

spoon_ai/agents/base.py

@@ -74,6 +74,8 @@ class BaseAgent(BaseModel, ABC):
 
     llm: ChatBot = Field(..., description="The LLM to use for the agent")
     memory: Memory = Field(default_factory=Memory, description="The memory to use for the agent")
+    enable_long_term_memory: bool = Field(default=False, description="Enable Mem0-based long-term memory")
+    mem0_config: Dict[str, Any] = Field(default_factory=dict, description="Mem0 configuration passed to the LLM client")
     state: AgentState = Field(default=AgentState.IDLE, description="The state of the agent")
 
     max_steps: int = Field(default=10, description="The maximum number of steps the agent can take")
@@ -113,6 +115,16 @@ def __init__(self, **kwargs):
         # Concurrency control
         self._active_operations = set()
         self._shutdown_event = asyncio.Event()
+
+        # Long-term memory configuration (Mem0)
+        self.mem0_config = self.mem0_config or {}
+        if self.name:
+            self.mem0_config.setdefault("agent_id", self.name)
+        if isinstance(self.llm, ChatBot):
+            try:
+                self.llm.update_mem0_config(self.mem0_config, enable=self.enable_long_term_memory)
+            except Exception as exc:
+                logger.warning("Unable to configure Mem0 for agent %s: %s", self.name, exc)
 
         # Initialize callback manager
         self._callback_manager = CallbackManager.from_callbacks(self.callbacks)