feat: extract facts with main agent LLM, bypass mem0 GPT-nano

Instead of hacking mem0's provider system, use the main agent's
existing LLM (already running, already paid for) to extract facts
from conversations, then store them with infer=False.

- extract_facts(): sends conversation to provider.chat() with extraction prompt
- store_facts(): stores each fact via mem0 with infer=False
- consolidate(): calls extract_facts + store_facts instead of add_conversation
- No new files, no Dockerfile changes, no mem0 package patches

nanobot/agent/loop.py

@@ -40,8 +40,8 @@ class AgentLoop:
     5. Sends responses back
     """
 
-    # Server-side context management: Anthropic preserves all thinking blocks
-    # and clears old tool results only when approaching the 200k context limit.
+    # Server-side context management: Anthropic trims old tool results and preserves all
+    # thinking blocks (keep="all" maximises cache hits). Client keeps full history.
     CONTEXT_MANAGEMENT = {
         "edits": [
             {
@@ -50,11 +50,7 @@ class AgentLoop:
             },
             {
                 "type": "clear_tool_uses_20250919",
-                # Raised from 80k to 195k to avoid premature cache invalidation.
-                # For conversations with few tool uses (e.g., 18 uses over 182k tokens),
-                # cache stability (saves 169k/turn) >> clearing benefit (13-26k one-time).
-                # Leaves 5k headroom before hitting 200k standard context limit.
-                "trigger": {"type": "input_tokens", "value": 195000},
+                "trigger": {"type": "input_tokens", "value": 80000},
                 "keep": {"type": "tool_uses", "value": 5},
             },
         ]
@@ -567,23 +563,10 @@ class AgentLoop:
             reasoning_content=final_reasoning,
         )
 
-        # Save to session: mem0 context (if present) + user message + full tool chain
+        # Save to session: user message + full tool chain (tool_use, tool_results, thinking, final reply)
         # Store current_message (not msg.content) so the time prefix is preserved
+        # and cache keys match on subsequent turns
         # Include sender_id to distinguish real user messages from system-generated ones
-
-        # Find and save mem0 injection (appears just before current user message)
-        # build_messages returns: [...history, mem0_user, mem0_asst, current_user]
-        # turn_start = len(messages), so mem0 is at turn_start-3 and turn_start-2
-        # This makes mem0 part of immutable history, stabilizing cache across turns
-        if turn_start >= 3:
-            potential_mem0_user = messages[turn_start - 3]
-            potential_mem0_asst = messages[turn_start - 2]
-            if (potential_mem0_user.get("role") == "user" and
-                potential_mem0_user.get("content") == "[Memory context]" and
-                potential_mem0_asst.get("role") == "assistant"):
-                session.add_raw_message(potential_mem0_user)
-                session.add_raw_message(potential_mem0_asst)
-
         session.add_message("user", current_message, sender_id=msg.sender_id)
         for chain_msg in messages[turn_start:]:
             session.add_raw_message(chain_msg)
@@ -786,17 +769,7 @@ class AgentLoop:
             reasoning_content=final_reasoning,
         )
 
-        # Save to session: mem0 (if present) + user message + full tool chain
-        # Find and save mem0 injection for cache stability
-        if turn_start >= 3:
-            potential_mem0_user = messages[turn_start - 3]
-            potential_mem0_asst = messages[turn_start - 2]
-            if (potential_mem0_user.get("role") == "user" and
-                potential_mem0_user.get("content") == "[Memory context]" and
-                potential_mem0_asst.get("role") == "assistant"):
-                session.add_raw_message(potential_mem0_user)
-                session.add_raw_message(potential_mem0_asst)
-
+        # Save to session: user message + full tool chain
         session.add_message("user", f"[System: {msg.sender_id}] {msg.content}")
         for chain_msg in messages[turn_start:]:
             session.add_raw_message(chain_msg)

nanobot/agent/memory_mem0.py

@@ -58,6 +58,346 @@ class Mem0MemoryStore:
                 mem0_cfg_dict[key] = raw_config[key]
         logger.debug(f"Extracted for MemoryConfig: {list(mem0_cfg_dict.keys())}")
         logger.debug(f"Custom prompt length: {len(custom_prompt)} chars")
+        self.custom_prompt = custom_prompt
+        mem0_cfg_dict["custom_fact_extraction_prompt"] = custom_prompt
+        mem0_config = MemoryConfig(**mem0_cfg_dict)
+        logger.debug(f"MemoryConfig created: vector_store={mem0_config.vector_store.provider if mem0_config.vector_store else None}")
+        logger.debug(f"MemoryConfig.custom_fact_extraction_prompt is None: {mem0_config.custom_fact_extraction_prompt is None}")
+        self.memory = Memory(config=mem0_config)
+        logger.debug(f"Memory.config.custom_fact_extraction_prompt is None: {self.memory.config.custom_fact_extraction_prompt is None}")
+
+        logger.info("Mem0 memory system initialized with custom nanobot prompt")
+
+    def search_memories(
+        self,
+        query: str,
+        user_id: str,
+        limit: int = 5,
+        session_id: str | None = None,
+    ) -> list[dict[str, Any]]:
+        """
+        Search for relevant memories using semantic search.
+
+        Args:
+            query: Search query (user's current message)
+            user_id: User identifier (e.g., "telegram_12345")
+            limit: Max number of memories to return
+            session_id: Optional session-specific memories
+
+        Returns:
+            List of memory dicts with 'memory' and 'score' keys
+        """
+        try:
+            # Search user-level memories
+            user_memories = self.memory.search(
+                query=query,
+                user_id=user_id,
+                limit=limit
+            )
+
+            results = []
+            if user_memories and "results" in user_memories:
+                results.extend(user_memories["results"])
+
+            # Optionally search session-level memories
+            if session_id:
+                session_memories = self.memory.search(
+                    query=query,
+                    user_id=user_id,
+                    metadata={"session_id": session_id},
+                    limit=limit // 2  # Reserve half for session context
+                )
+                if session_memories and "results" in session_memories:
+                    results.extend(session_memories["results"])
+
+            logger.debug(
+                f"Mem0 search: query='{query[:50]}...', found {len(results)} memories"
+            )
+            return results[:limit]  # Limit total results
+
+        except Exception as e:
+            logger.error(f"Mem0 search failed: {e}")
+            return []
+
+    def add_conversation(
+        self,
+        messages: list[dict[str, Any]],
+        user_id: str,
+        session_id: str | None = None,
+    ) -> None:
+        """
+        Add conversation messages to memory for automatic extraction.
+
+        Args:
+            messages: List of message dicts with 'role' and 'content'
+            user_id: User identifier
+            session_id: Optional session identifier for session-level memories
+        """
+        try:
+            metadata = {}
+            if session_id:
+                metadata["session_id"] = session_id
+
+            # mem0 automatically extracts and stores relevant facts
+            result = self.memory.add(
+                messages,
+                user_id=user_id,
+                metadata=metadata if metadata else None
+            )
+
+            facts_count = len(result.get("results", [])) if result else 0
+            logger.debug(
+                f"Mem0 add: {len(messages)} messages for user {user_id}, extracted {facts_count} facts"
+            )
+        except Exception as e:
+            logger.error(f"Mem0 add failed: {e}")
+
+    async def extract_facts(
+        self,
+        messages: list[dict[str, Any]],
+        provider: Any,
+        model: str,
+    ) -> list[str]:
+        """
+        Extract facts from conversation using the main agent's LLM provider.
+
+        Uses the same provider/model already running (e.g. Haiku via Claude Max),
+        avoiding a separate LLM call to mem0's default GPT-nano.
+        """
+        import json as _json
+
+        # Build conversation text for extraction
+        conv_text = ""
+        for msg in messages:
+            role = msg.get("role", "unknown")
+            content = msg.get("content", "")
+            if isinstance(content, str) and content.strip():
+                conv_text += f"{role}: {content}\n\n"
+
+        if not conv_text.strip():
+            return []
+
+        extraction_messages = [
+            {"role": "user", "content": self.custom_prompt + conv_text}
+        ]
+
+        try:
+            response = await provider.chat(
+                messages=extraction_messages,
+                model=model,
+                max_tokens=2000,
+                temperature=0.3,
+            )
+
+            # Parse the JSON response — LLMResponse.content is a string
+            text = response.content or ""
+            # Strip markdown code fences if present
+            text = text.strip()
+            if text.startswith("```"):
+                text = text.split("\n", 1)[1] if "\n" in text else text[3:]
+            if text.endswith("```"):
+                text = text[:-3]
+            text = text.strip()
+
+            data = _json.loads(text)
+            facts = data.get("facts", [])
+            logger.debug(f"Extracted {len(facts)} facts using {model}")
+            return facts
+
+        except Exception as e:
+            logger.error(f"Fact extraction failed: {e}")
+            return []
+
+    def store_facts(
+        self,
+        facts: list[str],
+        user_id: str,
+        session_id: str | None = None,
+    ) -> None:
+        """
+        Store pre-extracted facts in mem0 with infer=False.
+
+        Bypasses mem0's built-in LLM extraction — facts are already
+        in final form from extract_facts().
+        """
+        if not facts:
+            return
+
+        metadata = {}
+        if session_id:
+            metadata["session_id"] = session_id
+
+        stored = 0
+        for fact in facts:
+            try:
+                self.memory.add(
+                    fact,
+                    user_id=user_id,
+                    infer=False,
+                    metadata=metadata if metadata else None,
+                )
+                stored += 1
+            except Exception as e:
+                logger.error(f"Failed to store fact '{fact[:50]}...': {e}")
+
+        logger.info(f"Stored {stored}/{len(facts)} facts for user {user_id}")
+
+    def get_memory_context(
+        self,
+        query: str,
+        user_id: str,
+        limit: int = 5
+    ) -> str:
+        """
+        Get formatted memory context for inclusion in system prompt.
+
+        Args:
+            query: Current user query
+            user_id: User identifier
+            limit: Max memories to include
+
+        Returns:
+            Formatted memory context string
+        """
+        memories = self.search_memories(query, user_id, limit=limit)
+
+        if not memories:
+            return ""
+
+        lines = ["## Relevant Memories"]
+        for i, mem in enumerate(memories, 1):
+            memory_text = mem.get("memory", "")
+            # Include score if available for debugging
+            score = mem.get("score", "")
+            score_str = f" (relevance: {score:.2f})" if score else ""
+            lines.append(f"{i}. {memory_text}{score_str}")
+
+        return "\n".join(lines)
+
+    def update_memory(self, memory_id: str, data: dict[str, Any]) -> None:
+        """Update a specific memory by ID."""
+        try:
+            self.memory.update(memory_id, data)
+            logger.debug(f"Mem0 update: memory_id={memory_id}")
+        except Exception as e:
+            logger.error(f"Mem0 update failed: {e}")
+
+    def delete_memory(self, memory_id: str) -> None:
+        """Delete a specific memory by ID."""
+        try:
+            self.memory.delete(memory_id)
+            logger.debug(f"Mem0 delete: memory_id={memory_id}")
+        except Exception as e:
+            logger.error(f"Mem0 delete failed: {e}")
+
+    def get_all_memories(self, user_id: str) -> list[dict[str, Any]]:
+        """Get all memories for a user."""
+        try:
+            result = self.memory.get_all(user_id=user_id)
+            return result.get("results", []) if result else []
+        except Exception as e:
+            logger.error(f"Mem0 get_all failed: {e}")
+            return []
+
+    async def consolidate(
+        self,
+        session: Session,
+        provider: LLMProvider,
+        model: str,
+        *,
+        archive_all: bool = False,
+        memory_window: int = 50,
+    ) -> bool:
+        """
+        Consolidate session messages into mem0 memory.
+
+        Facts are extracted using the main agent's LLM provider, then stored with infer=False.
+
+        Returns True on success.
+        """
+        try:
+            # Extract user_id from session key (e.g., "telegram:12345" -> "telegram_12345")
+            user_id = session.key.replace(":", "_")
+
+            # Determine which messages to consolidate
+            if archive_all:
+                messages_to_add = session.messages
+                logger.info(
+                    f"Mem0 consolidation (archive_all): {len(messages_to_add)} messages"
+                )
+            else:
+                keep_count = memory_window // 2
+                if len(session.messages) <= keep_count:
+                    return True
+
+                # Get unconsolidated messages
+                start_idx = session.last_consolidated
+                end_idx = len(session.messages) - keep_count
+
+                if end_idx <= start_idx:
+                    return True
+
+                messages_to_add = session.messages[start_idx:end_idx]
+
+                if not messages_to_add:
+                    return True
+
+                logger.info(
+                    f"Mem0 consolidation: {len(messages_to_add)} to consolidate, "
+                    f"{keep_count} keep"
+                )
+
+            # Convert to mem0 format with intelligent filtering
+            mem0_messages = []
+            for msg in messages_to_add:
+                role = msg.get("role")
+                content = msg.get("content")
+
+                # Skip tool results — raw bash output, file contents, and JSON
+                # get misinterpreted by the extraction LLM as user interests
+                if role == "tool":
+                    continue
+
+                # Skip system messages — they're boilerplate instructions, not facts
+                if role == "system":
+                    continue
+
+                # Skip messages with no content
+                if not content:
+                    continue
+
+                # Normalize assistant message content: extract text from Anthropic list format
+                if role == "assistant" and isinstance(content, list):
+                    # Anthropic format: list of {type: "text"|"tool_use", text: "..."} blocks
+                    text_parts = [
+                        block.get("text", "")
+                        for block in content
+                        if isinstance(block, dict) and block.get("type") == "text"
+                    ]
+                    content = " ".join(text_parts).strip()
+                    if not content:
+                        continue  # Skip if assistant only called tools with no text explanation
+
+                # Normalize user message content (could also be a list in some formats)
+                if isinstance(content, list):
+                    text_parts = [
+                        block.get("text", "") if isinstance(block, dict) else str(block)
+                        for block in content
+                    ]
+                    content = " ".join(text_parts).strip()
+                    if not content:
+                        continue
+
+                # Skip trivially short messages (commands like "/new")
+                if len(content.strip()) < 10:
+                    continue
+
+                mem0_messages.append({
+                    "role": role,
+                    "content": content
+                })
+
+            if mem0_messages:
                 # Extract facts using the main agent's LLM (already paid for),
                 # then store with infer=False to bypass mem0's GPT-nano
                 facts = await self.extract_facts(mem0_messages, provider, model)

nanobot/providers/anthropic_oauth.py

@@ -326,35 +326,18 @@ class AnthropicOAuthProvider(LLMProvider):
         """Make request to Anthropic API."""
         client = await self._get_client()
 
-        # Add cache breakpoints on the last TWO user messages (4-breakpoint strategy):
-        # BP3: Second-to-last user message (stable history from previous turn)
-        # BP4: Last user message (current turn, will become BP3 next turn)
-        # This allows BP3 to reuse what BP4 cached last turn.
-        user_indices = [i for i, m in enumerate(messages) if m.get("role") == "user"]
-
-        if len(user_indices) >= 2:
-            # BP3: Second-to-last user message
-            idx = user_indices[-2]
-            msg = messages[idx]
-            content = msg["content"]
-            if isinstance(content, str):
-                messages[idx] = {**msg, "content": [{"type": "text", "text": content, "cache_control": {"type": "ephemeral"}}]}
-            elif isinstance(content, list) and content:
-                new_content = list(content)
-                new_content[-1] = {**new_content[-1], "cache_control": {"type": "ephemeral"}}
-                messages[idx] = {**msg, "content": new_content}
-
-        if len(user_indices) >= 1:
-            # BP4: Last user message
-            idx = user_indices[-1]
-            msg = messages[idx]
-            content = msg["content"]
-            if isinstance(content, str):
-                messages[idx] = {**msg, "content": [{"type": "text", "text": content, "cache_control": {"type": "ephemeral"}}]}
-            elif isinstance(content, list) and content:
-                new_content = list(content)
-                new_content[-1] = {**new_content[-1], "cache_control": {"type": "ephemeral"}}
-                messages[idx] = {**msg, "content": new_content}
+        # Cache the last user message so conversation history is cached across turns
+        if messages:
+            last = messages[-1]
+            if last.get("role") == "user":
+                content = last["content"]
+                if isinstance(content, str):
+                    last = {**last, "content": [{"type": "text", "text": content, "cache_control": {"type": "ephemeral"}}]}
+                elif isinstance(content, list) and content:
+                    new_content = list(content)
+                    new_content[-1] = {**new_content[-1], "cache_control": {"type": "ephemeral"}}
+                    last = {**last, "content": new_content}
+                messages = messages[:-1] + [last]
 
         payload: dict[str, Any] = {
             "model": model,