Merge develop into main

Includes fix for recall and remember tool loading.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

reachy_mini_language_tutor/profiles/german_tutor/recall.py

@@ -1,50 +0,0 @@
-"""Recall tool for searching learner memories."""
-
-from __future__ import annotations
-from typing import Any
-
-from reachy_mini_language_tutor.tools.core_tools import Tool, ToolDependencies
-
-
-class RecallTool(Tool):
-    """Search persistent memory for information about the learner."""
-
-    name = "recall"
-    description = (
-        "Search your memory for information about this learner from previous sessions. "
-        "Use this to check their progress, preferences, or past struggles before giving advice."
-    )
-    parameters_schema: dict[str, Any] = {
-        "type": "object",
-        "properties": {
-            "query": {
-                "type": "string",
-                "description": (
-                    "What to search for, e.g., 'vocabulary struggles', 'preferred topics', "
-                    "'last session progress', 'grammar they find difficult'"
-                ),
-            },
-        },
-        "required": ["query"],
-    }
-
-    async def __call__(self, deps: ToolDependencies, **kwargs: Any) -> dict[str, Any]:
-        """Search memories for the given query.
-
-        Args:
-            deps: Tool dependencies including memory_manager.
-            **kwargs: Tool arguments including 'query'.
-
-        Returns:
-            Dictionary with search results or error.
-
-        """
-        if not deps.memory_manager:
-            return {"error": "Memory not available", "memories": []}
-
-        query = kwargs.get("query", "")
-        if not query:
-            return {"error": "No query provided", "memories": []}
-
-        results = await deps.memory_manager.search(query)
-        return {"memories": results, "count": len(results)}

reachy_mini_language_tutor/profiles/german_tutor/remember.py

@@ -1,63 +0,0 @@
-"""Remember tool for storing learner facts in persistent memory."""
-
-from __future__ import annotations
-from typing import Any
-
-from reachy_mini_language_tutor.tools.core_tools import Tool, ToolDependencies
-
-
-class RememberTool(Tool):
-    """Store important facts about the learner for future sessions."""
-
-    name = "remember"
-    description = (
-        "Store an important fact about this learner for future sessions. "
-        "Use this to record progress, struggles, preferences, successes, or personal information "
-        "so you can provide personalized tutoring next time."
-    )
-    parameters_schema: dict[str, Any] = {
-        "type": "object",
-        "properties": {
-            "fact": {
-                "type": "string",
-                "description": (
-                    "The fact to remember, e.g., 'Learner struggles with passe compose', "
-                    "'Prefers topics about travel', 'Successfully used subjunctive today', "
-                    "'Learner's name is Marie', 'Lives in Toronto', 'Works as a teacher'"
-                ),
-            },
-            "category": {
-                "type": "string",
-                "enum": ["progress", "preference", "struggle", "success", "personal"],
-                "description": (
-                    "Category of the memory: progress (general notes), preference (what they like), "
-                    "struggle (what's difficult), success (what they mastered), "
-                    "personal (identity, interests, background, goals)"
-                ),
-            },
-        },
-        "required": ["fact", "category"],
-    }
-
-    async def __call__(self, deps: ToolDependencies, **kwargs: Any) -> dict[str, Any]:
-        """Store a fact in memory.
-
-        Args:
-            deps: Tool dependencies including memory_manager.
-            **kwargs: Tool arguments including 'fact' and 'category'.
-
-        Returns:
-            Dictionary with confirmation or error.
-
-        """
-        if not deps.memory_manager:
-            return {"error": "Memory not available", "stored": False}
-
-        fact = kwargs.get("fact", "")
-        category = kwargs.get("category", "progress")
-
-        if not fact:
-            return {"error": "No fact provided", "stored": False}
-
-        await deps.memory_manager.store(fact, category)
-        return {"stored": True, "fact": fact, "category": category}

reachy_mini_language_tutor/profiles/italian_tutor/recall.py

@@ -1,50 +0,0 @@
-"""Recall tool for searching learner memories."""
-
-from __future__ import annotations
-from typing import Any
-
-from reachy_mini_language_tutor.tools.core_tools import Tool, ToolDependencies
-
-
-class RecallTool(Tool):
-    """Search persistent memory for information about the learner."""
-
-    name = "recall"
-    description = (
-        "Search your memory for information about this learner from previous sessions. "
-        "Use this to check their progress, preferences, or past struggles before giving advice."
-    )
-    parameters_schema: dict[str, Any] = {
-        "type": "object",
-        "properties": {
-            "query": {
-                "type": "string",
-                "description": (
-                    "What to search for, e.g., 'vocabulary struggles', 'preferred topics', "
-                    "'last session progress', 'grammar they find difficult'"
-                ),
-            },
-        },
-        "required": ["query"],
-    }
-
-    async def __call__(self, deps: ToolDependencies, **kwargs: Any) -> dict[str, Any]:
-        """Search memories for the given query.
-
-        Args:
-            deps: Tool dependencies including memory_manager.
-            **kwargs: Tool arguments including 'query'.
-
-        Returns:
-            Dictionary with search results or error.
-
-        """
-        if not deps.memory_manager:
-            return {"error": "Memory not available", "memories": []}
-
-        query = kwargs.get("query", "")
-        if not query:
-            return {"error": "No query provided", "memories": []}
-
-        results = await deps.memory_manager.search(query)
-        return {"memories": results, "count": len(results)}

reachy_mini_language_tutor/profiles/italian_tutor/remember.py

@@ -1,63 +0,0 @@
-"""Remember tool for storing learner facts in persistent memory."""
-
-from __future__ import annotations
-from typing import Any
-
-from reachy_mini_language_tutor.tools.core_tools import Tool, ToolDependencies
-
-
-class RememberTool(Tool):
-    """Store important facts about the learner for future sessions."""
-
-    name = "remember"
-    description = (
-        "Store an important fact about this learner for future sessions. "
-        "Use this to record progress, struggles, preferences, successes, or personal information "
-        "so you can provide personalized tutoring next time."
-    )
-    parameters_schema: dict[str, Any] = {
-        "type": "object",
-        "properties": {
-            "fact": {
-                "type": "string",
-                "description": (
-                    "The fact to remember, e.g., 'Learner struggles with passe compose', "
-                    "'Prefers topics about travel', 'Successfully used subjunctive today', "
-                    "'Learner's name is Marie', 'Lives in Toronto', 'Works as a teacher'"
-                ),
-            },
-            "category": {
-                "type": "string",
-                "enum": ["progress", "preference", "struggle", "success", "personal"],
-                "description": (
-                    "Category of the memory: progress (general notes), preference (what they like), "
-                    "struggle (what's difficult), success (what they mastered), "
-                    "personal (identity, interests, background, goals)"
-                ),
-            },
-        },
-        "required": ["fact", "category"],
-    }
-
-    async def __call__(self, deps: ToolDependencies, **kwargs: Any) -> dict[str, Any]:
-        """Store a fact in memory.
-
-        Args:
-            deps: Tool dependencies including memory_manager.
-            **kwargs: Tool arguments including 'fact' and 'category'.
-
-        Returns:
-            Dictionary with confirmation or error.
-
-        """
-        if not deps.memory_manager:
-            return {"error": "Memory not available", "stored": False}
-
-        fact = kwargs.get("fact", "")
-        category = kwargs.get("category", "progress")
-
-        if not fact:
-            return {"error": "No fact provided", "stored": False}
-
-        await deps.memory_manager.store(fact, category)
-        return {"stored": True, "fact": fact, "category": category}

reachy_mini_language_tutor/profiles/portuguese_tutor/recall.py

@@ -1,50 +0,0 @@
-"""Recall tool for searching learner memories."""
-
-from __future__ import annotations
-from typing import Any
-
-from reachy_mini_language_tutor.tools.core_tools import Tool, ToolDependencies
-
-
-class RecallTool(Tool):
-    """Search persistent memory for information about the learner."""
-
-    name = "recall"
-    description = (
-        "Search your memory for information about this learner from previous sessions. "
-        "Use this to check their progress, preferences, or past struggles before giving advice."
-    )
-    parameters_schema: dict[str, Any] = {
-        "type": "object",
-        "properties": {
-            "query": {
-                "type": "string",
-                "description": (
-                    "What to search for, e.g., 'vocabulary struggles', 'preferred topics', "
-                    "'last session progress', 'grammar they find difficult'"
-                ),
-            },
-        },
-        "required": ["query"],
-    }
-
-    async def __call__(self, deps: ToolDependencies, **kwargs: Any) -> dict[str, Any]:
-        """Search memories for the given query.
-
-        Args:
-            deps: Tool dependencies including memory_manager.
-            **kwargs: Tool arguments including 'query'.
-
-        Returns:
-            Dictionary with search results or error.
-
-        """
-        if not deps.memory_manager:
-            return {"error": "Memory not available", "memories": []}
-
-        query = kwargs.get("query", "")
-        if not query:
-            return {"error": "No query provided", "memories": []}
-
-        results = await deps.memory_manager.search(query)
-        return {"memories": results, "count": len(results)}

reachy_mini_language_tutor/profiles/portuguese_tutor/remember.py

@@ -1,63 +0,0 @@
-"""Remember tool for storing learner facts in persistent memory."""
-
-from __future__ import annotations
-from typing import Any
-
-from reachy_mini_language_tutor.tools.core_tools import Tool, ToolDependencies
-
-
-class RememberTool(Tool):
-    """Store important facts about the learner for future sessions."""
-
-    name = "remember"
-    description = (
-        "Store an important fact about this learner for future sessions. "
-        "Use this to record progress, struggles, preferences, successes, or personal information "
-        "so you can provide personalized tutoring next time."
-    )
-    parameters_schema: dict[str, Any] = {
-        "type": "object",
-        "properties": {
-            "fact": {
-                "type": "string",
-                "description": (
-                    "The fact to remember, e.g., 'Learner struggles with passe compose', "
-                    "'Prefers topics about travel', 'Successfully used subjunctive today', "
-                    "'Learner's name is Marie', 'Lives in Toronto', 'Works as a teacher'"
-                ),
-            },
-            "category": {
-                "type": "string",
-                "enum": ["progress", "preference", "struggle", "success", "personal"],
-                "description": (
-                    "Category of the memory: progress (general notes), preference (what they like), "
-                    "struggle (what's difficult), success (what they mastered), "
-                    "personal (identity, interests, background, goals)"
-                ),
-            },
-        },
-        "required": ["fact", "category"],
-    }
-
-    async def __call__(self, deps: ToolDependencies, **kwargs: Any) -> dict[str, Any]:
-        """Store a fact in memory.
-
-        Args:
-            deps: Tool dependencies including memory_manager.
-            **kwargs: Tool arguments including 'fact' and 'category'.
-
-        Returns:
-            Dictionary with confirmation or error.
-
-        """
-        if not deps.memory_manager:
-            return {"error": "Memory not available", "stored": False}
-
-        fact = kwargs.get("fact", "")
-        category = kwargs.get("category", "progress")
-
-        if not fact:
-            return {"error": "No fact provided", "stored": False}
-
-        await deps.memory_manager.store(fact, category)
-        return {"stored": True, "fact": fact, "category": category}

reachy_mini_language_tutor/profiles/spanish_tutor/recall.py

@@ -1,50 +0,0 @@
-"""Recall tool for searching learner memories."""
-
-from __future__ import annotations
-from typing import Any
-
-from reachy_mini_language_tutor.tools.core_tools import Tool, ToolDependencies
-
-
-class RecallTool(Tool):
-    """Search persistent memory for information about the learner."""
-
-    name = "recall"
-    description = (
-        "Search your memory for information about this learner from previous sessions. "
-        "Use this to check their progress, preferences, or past struggles before giving advice."
-    )
-    parameters_schema: dict[str, Any] = {
-        "type": "object",
-        "properties": {
-            "query": {
-                "type": "string",
-                "description": (
-                    "What to search for, e.g., 'vocabulary struggles', 'preferred topics', "
-                    "'last session progress', 'grammar they find difficult'"
-                ),
-            },
-        },
-        "required": ["query"],
-    }
-
-    async def __call__(self, deps: ToolDependencies, **kwargs: Any) -> dict[str, Any]:
-        """Search memories for the given query.
-
-        Args:
-            deps: Tool dependencies including memory_manager.
-            **kwargs: Tool arguments including 'query'.
-
-        Returns:
-            Dictionary with search results or error.
-
-        """
-        if not deps.memory_manager:
-            return {"error": "Memory not available", "memories": []}
-
-        query = kwargs.get("query", "")
-        if not query:
-            return {"error": "No query provided", "memories": []}
-
-        results = await deps.memory_manager.search(query)
-        return {"memories": results, "count": len(results)}

reachy_mini_language_tutor/profiles/spanish_tutor/remember.py

@@ -1,63 +0,0 @@
-"""Remember tool for storing learner facts in persistent memory."""
-
-from __future__ import annotations
-from typing import Any
-
-from reachy_mini_language_tutor.tools.core_tools import Tool, ToolDependencies
-
-
-class RememberTool(Tool):
-    """Store important facts about the learner for future sessions."""
-
-    name = "remember"
-    description = (
-        "Store an important fact about this learner for future sessions. "
-        "Use this to record progress, struggles, preferences, successes, or personal information "
-        "so you can provide personalized tutoring next time."
-    )
-    parameters_schema: dict[str, Any] = {
-        "type": "object",
-        "properties": {
-            "fact": {
-                "type": "string",
-                "description": (
-                    "The fact to remember, e.g., 'Learner struggles with subjunctive', "
-                    "'Prefers topics about Mexican culture', 'Successfully used preterite vs imperfect today', "
-                    "'Learner's name is Carlos', 'Lives in Austin', 'Planning trip to Mexico City'"
-                ),
-            },
-            "category": {
-                "type": "string",
-                "enum": ["progress", "preference", "struggle", "success", "personal"],
-                "description": (
-                    "Category of the memory: progress (general notes), preference (what they like), "
-                    "struggle (what's difficult), success (what they mastered), "
-                    "personal (identity, interests, background, goals)"
-                ),
-            },
-        },
-        "required": ["fact", "category"],
-    }
-
-    async def __call__(self, deps: ToolDependencies, **kwargs: Any) -> dict[str, Any]:
-        """Store a fact in memory.
-
-        Args:
-            deps: Tool dependencies including memory_manager.
-            **kwargs: Tool arguments including 'fact' and 'category'.
-
-        Returns:
-            Dictionary with confirmation or error.
-
-        """
-        if not deps.memory_manager:
-            return {"error": "Memory not available", "stored": False}
-
-        fact = kwargs.get("fact", "")
-        category = kwargs.get("category", "progress")
-
-        if not fact:
-            return {"error": "No fact provided", "stored": False}
-
-        await deps.memory_manager.store(fact, category)
-        return {"stored": True, "fact": fact, "category": category}

reachy_mini_language_tutor/{profiles/french_tutor → tools}/remember.py

@@ -21,9 +21,9 @@ class RememberTool(Tool):
             "fact": {
                 "type": "string",
                 "description": (
-                    "The fact to remember, e.g., 'Learner struggles with passe compose', "
-                    "'Prefers topics about travel', 'Successfully used subjunctive today', "
-                    "'Learner's name is Marie', 'Lives in Toronto', 'Works as a teacher'"
+                    "The fact to remember, e.g., 'Learner struggles with verb conjugation', "
+                    "'Prefers topics about travel and culture', 'Successfully used past tense today', "
+                    "'Learner's name is Alex', 'Lives in Boston', 'Works as an engineer'"
                 ),
             },
             "category": {