mindroom 0.0.0__py3-none-any.whl → 0.1.1__py3-none-any.whl

mindroom/memory/__init__.py

@@ -0,0 +1,21 @@
+"""Memory management for mindroom agents and rooms."""
+
+from .functions import (
+    add_agent_memory,
+    add_room_memory,
+    build_memory_enhanced_prompt,
+    format_memories_as_context,
+    search_agent_memories,
+    search_room_memories,
+    store_conversation_memory,
+)
+
+__all__ = [
+    "add_agent_memory",
+    "add_room_memory",
+    "build_memory_enhanced_prompt",
+    "format_memories_as_context",
+    "search_agent_memories",
+    "search_room_memories",
+    "store_conversation_memory",
+]

mindroom/memory/config.py

@@ -0,0 +1,137 @@
+"""Memory configuration and setup."""
+
+import os
+from pathlib import Path
+from typing import Any
+
+from mem0 import AsyncMemory
+
+from mindroom.config import Config
+from mindroom.credentials import get_credentials_manager
+from mindroom.logging_config import get_logger
+
+logger = get_logger(__name__)
+
+
+def get_memory_config(storage_path: Path, config: Config) -> dict:  # noqa: C901, PLR0912
+    """Get Mem0 configuration with ChromaDB backend.
+
+    Args:
+        storage_path: Base directory for memory storage
+        config: Application configuration
+
+    Returns:
+        Configuration dictionary for Mem0
+
+    """
+    app_config = config
+    creds_manager = get_credentials_manager()
+
+    # Ensure storage directories exist
+    chroma_path = storage_path / "chroma"
+    chroma_path.mkdir(parents=True, exist_ok=True)
+
+    # Build embedder config from config.yaml
+    embedder_config: dict[str, Any] = {
+        "provider": app_config.memory.embedder.provider,
+        "config": {
+            "model": app_config.memory.embedder.config.model,
+        },
+    }
+
+    # Add provider-specific configuration
+    if app_config.memory.embedder.provider == "openai":
+        # Set environment variable from CredentialsManager for Mem0 to use
+        api_key = creds_manager.get_api_key("openai")
+        if api_key:
+            os.environ["OPENAI_API_KEY"] = api_key
+    elif app_config.memory.embedder.provider == "ollama":
+        # Check CredentialsManager for Ollama host
+        ollama_creds = creds_manager.load_credentials("ollama")
+        if ollama_creds and "host" in ollama_creds:
+            host = ollama_creds["host"]
+        else:
+            host = app_config.memory.embedder.config.host or "http://localhost:11434"
+        embedder_config["config"]["ollama_base_url"] = host
+
+    # Build LLM config from memory configuration
+    if app_config.memory.llm:
+        llm_config: dict[str, Any] = {
+            "provider": app_config.memory.llm.provider,
+            "config": {},
+        }
+
+        # Copy config but handle provider-specific field names
+        for key, value in app_config.memory.llm.config.items():
+            if key == "host" and app_config.memory.llm.provider == "ollama":
+                # Check CredentialsManager for Ollama host
+                ollama_creds = creds_manager.load_credentials("ollama")
+                if ollama_creds and "host" in ollama_creds:
+                    llm_config["config"]["ollama_base_url"] = ollama_creds["host"]
+                else:
+                    llm_config["config"]["ollama_base_url"] = value or "http://localhost:11434"
+            elif key != "host":  # Skip host for other fields
+                llm_config["config"][key] = value
+
+        # Set environment variables from CredentialsManager for Mem0 to use
+        if app_config.memory.llm.provider == "openai":
+            api_key = creds_manager.get_api_key("openai")
+            if api_key:
+                os.environ["OPENAI_API_KEY"] = api_key
+        elif app_config.memory.llm.provider == "anthropic":
+            api_key = creds_manager.get_api_key("anthropic")
+            if api_key:
+                os.environ["ANTHROPIC_API_KEY"] = api_key
+
+        logger.info(
+            f"Using {app_config.memory.llm.provider} model '{app_config.memory.llm.config.get('model')}' for memory",
+        )
+    else:
+        # Fallback if no LLM configured
+        logger.warning("No memory LLM configured, using default ollama/llama3.2")
+        # Check CredentialsManager for Ollama host
+        ollama_creds = creds_manager.load_credentials("ollama")
+        ollama_host = ollama_creds["host"] if ollama_creds and "host" in ollama_creds else "http://localhost:11434"
+
+        llm_config = {
+            "provider": "ollama",
+            "config": {
+                "model": "llama3.2",
+                "ollama_base_url": ollama_host,
+                "temperature": 0.1,
+                "top_p": 1,
+            },
+        }
+
+    return {
+        "embedder": embedder_config,
+        "llm": llm_config,
+        "vector_store": {
+            "provider": "chroma",
+            "config": {
+                "collection_name": "mindroom_memories",
+                "path": str(chroma_path),
+            },
+        },
+    }
+
+
+async def create_memory_instance(storage_path: Path, config: Config) -> AsyncMemory:
+    """Create a Mem0 memory instance with ChromaDB backend.
+
+    Args:
+        storage_path: Base directory for memory storage
+        config: Application configuration
+
+    Returns:
+        Configured AsyncMemory instance
+
+    """
+    config_dict = get_memory_config(storage_path, config)
+
+    # Create AsyncMemory instance with dictionary config directly
+    # Mem0 expects a dict for configuration, not config objects
+    memory = await AsyncMemory.from_config(config_dict)
+
+    logger.info(f"Created memory instance with ChromaDB at {storage_path}")
+    return memory

mindroom/memory/functions.py

@@ -0,0 +1,396 @@
+"""Simple memory management functions following Mem0 patterns."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, TypedDict
+
+from mindroom.logging_config import get_logger
+
+from .config import create_memory_instance
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+    from mindroom.config import Config
+
+
+class MemoryResult(TypedDict, total=False):
+    """Type for memory search results from Mem0."""
+
+    id: str
+    memory: str
+    hash: str
+    metadata: dict[str, Any] | None
+    score: float
+    created_at: str
+    updated_at: str | None
+    user_id: str
+
+
+logger = get_logger(__name__)
+
+
+async def add_agent_memory(
+    content: str,
+    agent_name: str,
+    storage_path: Path,
+    config: Config,
+    metadata: dict | None = None,
+) -> None:
+    """Add a memory for an agent.
+
+    Args:
+        content: The memory content to store
+        agent_name: Name of the agent
+        storage_path: Storage path for memory
+        config: Application configuration
+        metadata: Optional metadata to store with memory
+
+    """
+    memory = await create_memory_instance(storage_path, config)
+
+    if metadata is None:
+        metadata = {}
+    metadata["agent"] = agent_name
+
+    messages = [{"role": "user", "content": content}]
+
+    # Use agent_name as user_id to namespace memories per agent
+    try:
+        await memory.add(messages, user_id=f"agent_{agent_name}", metadata=metadata)
+        logger.info("Memory added", agent=agent_name)
+    except Exception as e:
+        logger.exception("Failed to add memory", agent=agent_name, error=str(e))
+
+
+def get_team_ids_for_agent(agent_name: str, config: Config) -> list[str]:
+    """Get all team IDs that include the specified agent.
+
+    Args:
+        agent_name: Name of the agent to find teams for
+        config: Application configuration containing team definitions
+
+    Returns:
+        List of team IDs (in the format "team_agent1+agent2+...")
+
+    """
+    team_ids: list[str] = []
+
+    if not config.teams:
+        return team_ids
+
+    for team_config in config.teams.values():
+        if agent_name in team_config.agents:
+            # Create the same team ID format used in storage
+            sorted_agents = sorted(team_config.agents)
+            team_id = f"team_{'+'.join(sorted_agents)}"
+            team_ids.append(team_id)
+
+    return team_ids
+
+
+async def search_agent_memories(
+    query: str,
+    agent_name: str,
+    storage_path: Path,
+    config: Config,
+    limit: int = 3,
+) -> list[MemoryResult]:
+    """Search agent memories including team memories.
+
+    Args:
+        query: Search query
+        agent_name: Name of the agent
+        storage_path: Storage path for memory
+        config: Application configuration
+        limit: Maximum number of results
+
+    Returns:
+        List of relevant memories from both individual and team contexts
+
+    """
+    memory = await create_memory_instance(storage_path, config)
+
+    # Search individual agent memories
+    search_result = await memory.search(query, user_id=f"agent_{agent_name}", limit=limit)
+    results = search_result["results"] if isinstance(search_result, dict) and "results" in search_result else []
+
+    # Also search team memories
+    team_ids = get_team_ids_for_agent(agent_name, config)
+    for team_id in team_ids:
+        team_result = await memory.search(query, user_id=team_id, limit=limit)
+        team_memories = team_result["results"] if isinstance(team_result, dict) and "results" in team_result else []
+
+        # Merge results, avoiding duplicates based on memory content
+        existing_memories = {r.get("memory", "") for r in results}
+        for mem in team_memories:
+            if mem.get("memory", "") not in existing_memories:
+                results.append(mem)
+
+        logger.debug("Team memories found", team_id=team_id, count=len(team_memories))
+
+    logger.debug("Total memories found", count=len(results), agent=agent_name)
+
+    # Return top results after merging
+    return results[:limit]
+
+
+async def add_room_memory(
+    content: str,
+    room_id: str,
+    storage_path: Path,
+    config: Config,
+    agent_name: str | None = None,
+    metadata: dict | None = None,
+) -> None:
+    """Add a memory for a room.
+
+    Args:
+        content: The memory content to store
+        room_id: Room ID
+        storage_path: Storage path for memory
+        config: Application configuration
+        agent_name: Optional agent that created this memory
+        metadata: Optional metadata to store with memory
+
+    """
+    memory = await create_memory_instance(storage_path, config)
+
+    if metadata is None:
+        metadata = {}
+    metadata["room_id"] = room_id
+    if agent_name:
+        metadata["contributed_by"] = agent_name
+
+    messages = [{"role": "user", "content": content}]
+
+    safe_room_id = room_id.replace(":", "_").replace("!", "")
+    await memory.add(messages, user_id=f"room_{safe_room_id}", metadata=metadata)
+    logger.debug("Room memory added", room_id=room_id)
+
+
+async def search_room_memories(
+    query: str,
+    room_id: str,
+    storage_path: Path,
+    config: Config,
+    limit: int = 3,
+) -> list[MemoryResult]:
+    """Search room memories.
+
+    Args:
+        query: Search query
+        room_id: Room ID
+        storage_path: Storage path for memory
+        config: Application configuration
+        limit: Maximum number of results
+
+    Returns:
+        List of relevant memories
+
+    """
+    memory = await create_memory_instance(storage_path, config)
+    safe_room_id = room_id.replace(":", "_").replace("!", "")
+    search_result = await memory.search(query, user_id=f"room_{safe_room_id}", limit=limit)
+
+    results = search_result["results"] if isinstance(search_result, dict) and "results" in search_result else []
+
+    logger.debug("Room memories found", count=len(results), room_id=room_id)
+    return results
+
+
+def format_memories_as_context(memories: list[MemoryResult], context_type: str = "agent") -> str:
+    """Format memories into a context string.
+
+    Args:
+        memories: List of memory objects from search
+        context_type: Type of context ("agent" or "room")
+
+    Returns:
+        Formatted context string
+
+    """
+    if not memories:
+        return ""
+
+    context_parts = [
+        f"[Automatically extracted {context_type} memories - may not be relevant to current context]",
+        f"Previous {context_type} memories that might be related:",
+    ]
+    for memory in memories:
+        content = memory.get("memory", "")
+        context_parts.append(f"- {content}")
+
+    return "\n".join(context_parts)
+
+
+async def build_memory_enhanced_prompt(
+    prompt: str,
+    agent_name: str,
+    storage_path: Path,
+    config: Config,
+    room_id: str | None = None,
+) -> str:
+    """Build a prompt enhanced with relevant memories.
+
+    Args:
+        prompt: The original user prompt
+        agent_name: Name of the agent
+        storage_path: Path for memory storage
+        config: Application configuration
+        room_id: Optional room ID for room context
+
+    Returns:
+        Enhanced prompt with memory context
+
+    """
+    logger.debug("Building enhanced prompt", agent=agent_name)
+    enhanced_prompt = prompt
+
+    agent_memories = await search_agent_memories(prompt, agent_name, storage_path, config)
+    if agent_memories:
+        agent_context = format_memories_as_context(agent_memories, "agent")
+        enhanced_prompt = f"{agent_context}\n\n{prompt}"
+        logger.debug("Agent memories added", count=len(agent_memories))
+
+    if room_id:
+        room_memories = await search_room_memories(prompt, room_id, storage_path, config)
+        if room_memories:
+            room_context = format_memories_as_context(room_memories, "room")
+            enhanced_prompt = f"{room_context}\n\n{enhanced_prompt}"
+            logger.debug("Room memories added", count=len(room_memories))
+
+    return enhanced_prompt
+
+
+def _build_conversation_messages(
+    thread_history: list[dict],
+    current_prompt: str,
+    user_id: str,
+) -> list[dict]:
+    """Build conversation messages in mem0 format from thread history.
+
+    Args:
+        thread_history: List of messages with sender and body
+        current_prompt: The current user prompt being processed
+        user_id: The Matrix user ID to identify user messages
+
+    Returns:
+        List of messages in mem0 format with role and content
+
+    """
+    messages = []
+
+    # Process thread history
+    for msg in thread_history:
+        body = msg.get("body", "").strip()
+        if not body:
+            continue
+
+        sender = msg.get("sender", "")
+        # Determine role based on sender
+        # If sender matches the user, it's a user message; otherwise it's assistant
+        role = "user" if sender == user_id else "assistant"
+        messages.append({"role": role, "content": body})
+
+    # Add the current prompt as a user message
+    messages.append({"role": "user", "content": current_prompt})
+
+    return messages
+
+
+async def store_conversation_memory(
+    prompt: str,
+    agent_name: str | list[str],
+    storage_path: Path,
+    session_id: str,
+    config: Config,
+    room_id: str | None = None,
+    thread_history: list[dict] | None = None,
+    user_id: str | None = None,
+) -> None:
+    """Store conversation in memory for future recall.
+
+    Uses mem0's intelligent extraction to identify relevant facts, preferences,
+    and context from the conversation. Provides full conversation context when
+    available to allow better understanding of user intent.
+
+    For teams, pass a list of agent names to store memory once under a shared
+    namespace, avoiding duplicate LLM processing.
+
+    Args:
+        prompt: The current user prompt
+        agent_name: Name of the agent or list of agent names for teams
+        storage_path: Path for memory storage
+        session_id: Session ID for the conversation
+        config: Application configuration
+        room_id: Optional room ID for room memory
+        thread_history: Optional thread history for context
+        user_id: Optional user ID to identify user messages in thread
+
+    """
+    if not prompt:
+        return
+
+    # Build conversation messages in mem0 format
+    if thread_history and user_id:
+        # Use structured messages with roles for better context
+        messages = _build_conversation_messages(thread_history, prompt, user_id)
+    else:
+        # Fallback to simple user message
+        messages = [{"role": "user", "content": prompt}]
+
+    # Store for agent memory with structured messages
+    memory = await create_memory_instance(storage_path, config)
+
+    # Handle both single agents and teams
+    is_team = isinstance(agent_name, list)
+
+    if is_team:
+        # For teams, store once under a team namespace
+        # Sort agent names for consistent team ID
+        sorted_agents = sorted(agent_name)
+        team_id = f"team_{'+'.join(sorted_agents)}"
+
+        metadata = {
+            "type": "conversation",
+            "session_id": session_id,
+            "is_team": True,
+            "team_members": agent_name,  # Keep original order for reference
+        }
+
+        try:
+            await memory.add(messages, user_id=team_id, metadata=metadata)
+            logger.info("Team memory added", team_id=team_id, members=agent_name)
+        except Exception as e:
+            logger.exception("Failed to add team memory", team_id=team_id, error=str(e))
+    else:
+        # Single agent - store normally
+        metadata = {
+            "type": "conversation",
+            "session_id": session_id,
+            "agent": agent_name,
+        }
+
+        try:
+            await memory.add(messages, user_id=f"agent_{agent_name}", metadata=metadata)
+            logger.info("Memory added", agent=agent_name)
+        except Exception as e:
+            logger.exception("Failed to add memory", agent=agent_name, error=str(e))
+
+    if room_id:
+        # Also store for room context
+        contributed_by = agent_name if isinstance(agent_name, str) else f"team:{','.join(agent_name)}"
+        room_metadata = {
+            "type": "conversation",
+            "session_id": session_id,
+            "room_id": room_id,
+            "contributed_by": contributed_by,
+        }
+
+        safe_room_id = room_id.replace(":", "_").replace("!", "")
+        try:
+            await memory.add(messages, user_id=f"room_{safe_room_id}", metadata=room_metadata)
+            logger.debug("Room memory added", room_id=room_id)
+        except Exception as e:
+            logger.exception("Failed to add room memory", room_id=room_id, error=str(e))

mindroom/response_tracker.py

@@ -0,0 +1,128 @@
+"""Track which messages have been responded to by agents."""
+
+from __future__ import annotations
+
+import fcntl
+import json
+import time
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, TypedDict
+
+from .constants import TRACKING_DIR
+from .logging_config import get_logger
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+logger = get_logger(__name__)
+
+
+class ResponseRecord(TypedDict):
+    """Record of a response to a user message."""
+
+    timestamp: float
+    response_id: str | None
+
+
+@dataclass
+class ResponseTracker:
+    """Track which event IDs have been responded to by an agent."""
+
+    agent_name: str
+    base_path: Path = TRACKING_DIR
+    _responses: dict[str, ResponseRecord] = field(default_factory=dict, init=False)
+    _responses_file: Path = field(init=False)
+
+    def __post_init__(self) -> None:
+        """Initialize paths and load existing responses."""
+        self.base_path.mkdir(parents=True, exist_ok=True)
+        self._responses_file = self.base_path / f"{self.agent_name}_responded.json"
+        self._load_responses()
+        # Perform automatic cleanup on initialization
+        self._cleanup_old_events()
+
+    def has_responded(self, event_id: str) -> bool:
+        """Check if we've already responded to this event.
+
+        Args:
+            event_id: The Matrix event ID
+
+        Returns:
+            True if we've already responded to this event
+
+        """
+        return event_id in self._responses
+
+    def mark_responded(self, event_id: str, response_event_id: str | None = None) -> None:
+        """Mark an event as responded to with current timestamp.
+
+        Args:
+            event_id: The Matrix event ID we responded to
+            response_event_id: The event ID of our response message (optional)
+
+        """
+        self._responses[event_id] = {
+            "timestamp": time.time(),
+            "response_id": response_event_id,
+        }
+        self._save_responses()
+        logger.debug(f"Marked event {event_id} as responded for agent {self.agent_name}")
+
+    def get_response_event_id(self, user_event_id: str) -> str | None:
+        """Get the response event ID for a given user message event ID.
+
+        Args:
+            user_event_id: The user's message event ID
+
+        Returns:
+            The agent's response event ID if it exists, None otherwise
+
+        """
+        record = self._responses.get(user_event_id)
+        return record["response_id"] if record else None
+
+    def _load_responses(self) -> None:
+        """Load the responses from disk."""
+        if not self._responses_file.exists():
+            self._responses = {}
+            return
+
+        with self._responses_file.open() as f:
+            data = json.load(f)
+            self._responses = data
+
+    def _save_responses(self) -> None:
+        """Save the responses to disk using file locking."""
+        with self._responses_file.open("w") as f:
+            fcntl.flock(f.fileno(), fcntl.LOCK_EX)
+            try:
+                json.dump(self._responses, f, indent=2)
+            finally:
+                fcntl.flock(f.fileno(), fcntl.LOCK_UN)
+
+    def _cleanup_old_events(self, max_events: int = 10000, max_age_days: int = 30) -> None:
+        """Remove old events based on count and age.
+
+        Args:
+            max_events: Maximum number of events to track
+            max_age_days: Maximum age of events in days
+
+        """
+        current_time = time.time()
+        max_age_seconds = max_age_days * 24 * 60 * 60
+
+        # First remove events older than max_age_days
+        self._responses = {
+            event_id: record
+            for event_id, record in self._responses.items()
+            if current_time - record["timestamp"] < max_age_seconds
+        }
+
+        # Then trim to max_events if still over limit
+        if len(self._responses) > max_events:
+            # Sort by timestamp and keep only the most recent ones
+            sorted_events = sorted(self._responses.items(), key=lambda x: x[1]["timestamp"])
+            self._responses = dict(sorted_events[-max_events:])
+
+        self._save_responses()
+        logger.info(f"Cleaned up old events for {self.agent_name}, keeping {len(self._responses)} events")