code/src/agents/memory.py

"""
Mem0 OSS wrapper for long-term CVE query memory.

Self-hosted — reuses existing Qdrant + HuggingFace embeddings.
Zero new infrastructure, zero API keys.

Gracefully degrades to no-op if mem0ai is not installed.
"""

from __future__ import annotations

import logging
from typing import Any, Dict, List, Optional

from src.agents.agent_config import (
    MEM0_ENABLED, MEM0_MAX_MEMORIES, MEM0_COLLECTION_NAME,
)
from src.generators.rag_config import (
    QDRANT_URL, QDRANT_API_KEY, EMBEDDING_MODEL_NAME,
    LLM_BASE_URL, LLM_API_KEY, LLM_MODEL_NAME,
)

logger = logging.getLogger(__name__)

_MEM0_AVAILABLE = False
try:
    from mem0 import Memory
    _MEM0_AVAILABLE = True
except ImportError:
    logger.info("mem0ai not installed — memory is disabled. Install with: pip install mem0ai")


def _build_mem0_config() -> dict:
    return {
        "vector_store": {
            "provider": "qdrant",
            "config": {
                "url": QDRANT_URL,
                "api_key": QDRANT_API_KEY,
                "collection_name": MEM0_COLLECTION_NAME,
            },
        },
        "llm": {
            "provider": "openai",
            "config": {
                "model": LLM_MODEL_NAME,
                "base_url": LLM_BASE_URL,
                "api_key": LLM_API_KEY
                if LLM_API_KEY and LLM_API_KEY != "not-needed"
                else "not-needed",
            },
        },
        "embedder": {
            "provider": "huggingface",
            "config": {"model": EMBEDDING_MODEL_NAME},
        },
        "history_db_path": "~/.mem0/cve_kgrag_history.db",
    }


class CVEKGMemory:
    """Long-term memory via Mem0. Stores/recalls past CVE queries and answers."""

    def __init__(self) -> None:
        self._client: Any = None
        if not MEM0_ENABLED:
            logger.info("Mem0 disabled via MEM0_ENABLED=false")
            return
        if not _MEM0_AVAILABLE:
            logger.info("Mem0 unavailable — pip install mem0ai to enable long-term memory")
            return
        try:
            config = _build_mem0_config()
            self._client = Memory.from_config(config)
            logger.info("Mem0 memory ready (Qdrant collection=%s)", MEM0_COLLECTION_NAME)
        except Exception as e:
            logger.warning("Mem0 init failed: %s — memory disabled", e)
            self._client = None

    def recall(self, query: str, user_id: str = "default_session") -> str:
        """Search past memories for relevant context. Returns empty string on failure."""
        if self._client is None:
            return ""
        try:
            results = self._client.search(
                query,
                filters={"user_id": user_id},
                limit=MEM0_MAX_MEMORIES,
            )
            memories = results.get("results", [])
            if not memories:
                return ""
            lines = ["[Past context from memory:]"]
            for m in memories:
                lines.append(f"- {m.get('memory', '')}")
            return "\n".join(lines)
        except Exception as e:
            logger.warning("Mem0 recall failed: %s", e)
            return ""

    def save(self, query: str, answer: str, user_id: str = "default_session") -> None:
        """Store an interaction. Mem0 auto-extracts key facts."""
        if self._client is None:
            return
        try:
            self._client.add(
                [
                    {"role": "user", "content": query},
                    {"role": "assistant", "content": answer},
                ],
                user_id=user_id,
            )
        except Exception as e:
            logger.warning("Mem0 save failed: %s", e)

    @property
    def enabled(self) -> bool:
        return self._client is not None