MemoryOS 0.1.12__py3-none-any.whl → 0.1.13__py3-none-any.whl

memos/memories/textual/tree_text_memory/retrieve/internet_retriever.py

@@ -0,0 +1,263 @@
+"""Internet retrieval module for tree text memory."""
+
+import uuid
+
+from datetime import datetime
+
+import requests
+
+from memos.embedders.factory import OllamaEmbedder
+from memos.memories.textual.item import TextualMemoryItem, TreeNodeTextualMemoryMetadata
+
+
+class GoogleCustomSearchAPI:
+    """Google Custom Search API Client"""
+
+    def __init__(
+        self, api_key: str, search_engine_id: str, max_results: int = 20, num_per_request: int = 10
+    ):
+        """
+        Initialize Google Custom Search API client
+
+        Args:
+            api_key: Google API key
+            search_engine_id: Search engine ID (cx parameter)
+            max_results: Maximum number of results to retrieve
+            num_per_request: Number of results per API request
+        """
+        self.api_key = api_key
+        self.search_engine_id = search_engine_id
+        self.max_results = max_results
+        self.num_per_request = min(num_per_request, 10)  # Google API limits to 10
+        self.base_url = "https://www.googleapis.com/customsearch/v1"
+
+    def search(self, query: str, num_results: int | None = None, start_index: int = 1) -> dict:
+        """
+        Execute search request
+
+        Args:
+            query: Search query
+            num_results: Number of results to return (uses config default if None)
+            start_index: Starting index (default 1)
+
+        Returns:
+            Dictionary containing search results
+        """
+        if num_results is None:
+            num_results = self.num_per_request
+
+        params = {
+            "key": self.api_key,
+            "cx": self.search_engine_id,
+            "q": query,
+            "num": min(num_results, self.num_per_request),
+            "start": start_index,
+        }
+
+        try:
+            response = requests.get(self.base_url, params=params)
+            response.raise_for_status()
+            return response.json()
+        except requests.exceptions.RequestException as e:
+            print(f"Google search request failed: {e}")
+            return {}
+
+    def get_all_results(self, query: str, max_results: int | None = None) -> list[dict]:
+        """
+        Get all search results (with pagination)
+
+        Args:
+            query: Search query
+            max_results: Maximum number of results (uses config default if None)
+
+        Returns:
+            List of all search results
+        """
+        if max_results is None:
+            max_results = self.max_results
+
+        all_results = []
+        start_index = 1
+
+        while len(all_results) < max_results:
+            search_data = self.search(query, start_index=start_index)
+
+            if not search_data or "items" not in search_data:
+                break
+
+            all_results.extend(search_data["items"])
+
+            # Check if there are more results
+            if len(search_data["items"]) < self.num_per_request:
+                break
+
+            start_index += self.num_per_request
+
+            # Avoid infinite loop
+            if start_index > 100:
+                break
+
+        return all_results[:max_results]
+
+
+class InternetGoogleRetriever:
+    """Internet retriever that converts search results to TextualMemoryItem format"""
+
+    def __init__(
+        self,
+        api_key: str,
+        search_engine_id: str,
+        embedder: OllamaEmbedder,
+        max_results: int = 20,
+        num_per_request: int = 10,
+    ):
+        """
+        Initialize internet retriever
+
+        Args:
+            api_key: Google API key
+            search_engine_id: Search engine ID
+            embedder: Embedder instance for generating embeddings
+            max_results: Maximum number of results to retrieve
+            num_per_request: Number of results per API request
+        """
+        self.google_api = GoogleCustomSearchAPI(
+            api_key, search_engine_id, max_results=max_results, num_per_request=num_per_request
+        )
+        self.embedder = embedder
+
+    def retrieve_from_internet(
+        self, query: str, top_k: int = 10, parsed_goal=None
+    ) -> list[TextualMemoryItem]:
+        """
+        Retrieve information from the internet and convert to TextualMemoryItem format
+
+        Args:
+            query: Search query
+            top_k: Number of results to return
+            parsed_goal: Parsed task goal (optional)
+
+        Returns:
+            List of TextualMemoryItem
+        """
+        # Get search results
+        search_results = self.google_api.get_all_results(query, max_results=top_k)
+
+        # Convert to TextualMemoryItem format
+        memory_items = []
+
+        for _, result in enumerate(search_results):
+            # Extract basic information
+            title = result.get("title", "")
+            snippet = result.get("snippet", "")
+            link = result.get("link", "")
+            display_link = result.get("displayLink", "")
+
+            # Combine memory content
+            memory_content = f"Title: {title}\nSummary: {snippet}\nSource: {link}"
+            # Create metadata
+            metadata = TreeNodeTextualMemoryMetadata(
+                user_id=None,
+                session_id=None,
+                status="activated",
+                type="fact",  # Internet search results are usually factual information
+                memory_time=datetime.now().strftime("%Y-%m-%d"),
+                source="web",
+                confidence=85.0,  # Confidence level for internet information
+                entities=self._extract_entities(title, snippet),
+                tags=self._extract_tags(title, snippet, parsed_goal),
+                visibility="public",
+                memory_type="LongTermMemory",  # Internet search results as working memory
+                key=title,
+                sources=[link] if link else [],
+                embedding=self.embedder.embed([memory_content])[0],  # Can add embedding later
+                created_at=datetime.now().isoformat(),
+                usage=[],
+                background=f"Internet search result from {display_link}",
+            )
+
+            # Create TextualMemoryItem
+            memory_item = TextualMemoryItem(
+                id=str(uuid.uuid4()), memory=memory_content, metadata=metadata
+            )
+
+            memory_items.append(memory_item)
+
+        return memory_items
+
+    def _extract_entities(self, title: str, snippet: str) -> list[str]:
+        """
+        Extract entities from title and snippet
+
+        Args:
+            title: Title
+            snippet: Snippet
+
+        Returns:
+            List of entities
+        """
+        # Simple entity extraction logic, can be improved as needed
+        text = f"{title} {snippet}"
+        entities = []
+
+        # Extract possible organization names (with common suffixes)
+        org_suffixes = ["Inc", "Corp", "LLC", "Ltd", "Company", "University", "Institute"]
+        words = text.split()
+        for i, word in enumerate(words):
+            if word in org_suffixes and i > 0:
+                entities.append(f"{words[i - 1]} {word}")
+
+        # Extract possible dates
+        import re
+
+        date_pattern = r"\d{4}-\d{2}-\d{2}|\d{1,2}/\d{1,2}/\d{4}|\w+ \d{1,2}, \d{4}"
+        dates = re.findall(date_pattern, text)
+        entities.extend(dates)
+
+        return entities[:5]  # Limit number of entities
+
+    def _extract_tags(self, title: str, snippet: str, parsed_goal=None) -> list[str]:
+        """
+        Extract tags from title and snippet
+
+        Args:
+            title: Title
+            snippet: Snippet
+            parsed_goal: Parsed task goal
+
+        Returns:
+            List of tags
+        """
+        tags = []
+
+        # Extract tags from parsed goal
+        if parsed_goal:
+            if hasattr(parsed_goal, "topic") and parsed_goal.topic:
+                tags.append(parsed_goal.topic)
+            if hasattr(parsed_goal, "concept") and parsed_goal.concept:
+                tags.append(parsed_goal.concept)
+
+        # Extract keywords from text
+        text = f"{title} {snippet}".lower()
+
+        # Simple keyword extraction
+        keywords = [
+            "news",
+            "report",
+            "article",
+            "study",
+            "research",
+            "analysis",
+            "update",
+            "announcement",
+            "policy",
+            "memo",
+            "document",
+        ]
+
+        for keyword in keywords:
+            if keyword in text:
+                tags.append(keyword)
+
+        # Remove duplicates and limit count
+        return list(set(tags))[:10]

memos/memories/textual/tree_text_memory/retrieve/internet_retriever_factory.py

@@ -0,0 +1,89 @@
+"""Factory for creating internet retrievers."""
+
+from typing import Any, ClassVar
+
+from memos.configs.internet_retriever import InternetRetrieverConfigFactory
+from memos.embedders.base import BaseEmbedder
+from memos.memories.textual.tree_text_memory.retrieve.internet_retriever import (
+    InternetGoogleRetriever,
+)
+from memos.memories.textual.tree_text_memory.retrieve.xinyusearch import XinyuSearchRetriever
+
+
+class InternetRetrieverFactory:
+    """Factory class for creating internet retriever instances."""
+
+    backend_to_class: ClassVar[dict[str, Any]] = {
+        "google": InternetGoogleRetriever,
+        "bing": InternetGoogleRetriever,  # TODO: Implement BingRetriever
+        "xinyu": XinyuSearchRetriever,
+    }
+
+    @classmethod
+    def from_config(
+        cls, config_factory: InternetRetrieverConfigFactory, embedder: BaseEmbedder
+    ) -> InternetGoogleRetriever | None:
+        """
+        Create internet retriever from configuration.
+
+        Args:
+            config_factory: Internet retriever configuration
+            embedder: Embedder instance for generating embeddings
+
+        Returns:
+            InternetRetriever instance or None if no configuration provided
+        """
+        if config_factory.backend is None:
+            return None
+
+        backend = config_factory.backend
+        if backend not in cls.backend_to_class:
+            raise ValueError(f"Invalid internet retriever backend: {backend}")
+
+        retriever_class = cls.backend_to_class[backend]
+        config = config_factory.config
+
+        # Create retriever with appropriate parameters
+        if backend == "google":
+            return retriever_class(
+                api_key=config.api_key,
+                search_engine_id=config.search_engine_id,
+                embedder=embedder,
+                max_results=config.max_results,
+                num_per_request=config.num_per_request,
+            )
+        elif backend == "bing":
+            # TODO: Implement Bing retriever
+            return retriever_class(
+                api_key=config.api_key,
+                search_engine_id=None,  # Bing doesn't use search_engine_id
+                embedder=embedder,
+                max_results=config.max_results,
+                num_per_request=config.num_per_request,
+            )
+        elif backend == "xinyu":
+            return retriever_class(
+                access_key=config.api_key,  # Use api_key as access_key for xinyu
+                search_engine_id=config.search_engine_id,
+                embedder=embedder,
+                max_results=config.max_results,
+            )
+        else:
+            raise ValueError(f"Unsupported backend: {backend}")
+
+    @classmethod
+    def create_google_retriever(
+        cls, api_key: str, search_engine_id: str, embedder: BaseEmbedder
+    ) -> InternetGoogleRetriever:
+        """
+        Create Google Custom Search retriever.
+
+        Args:
+            api_key: Google API key
+            search_engine_id: Google Custom Search Engine ID
+            embedder: Embedder instance
+
+        Returns:
+            InternetRetriever instance
+        """
+        return InternetGoogleRetriever(api_key, search_engine_id, embedder)

memos/memories/textual/tree_text_memory/retrieve/reasoner.py

@@ -34,10 +34,7 @@ class MemoryReasoner:
         """
         prompt_template = Template(REASON_PROMPT)
         memory_detailed_str = "\n".join(
-            [
-                f"[{m.id}] ({m.metadata.hierarchy_level}) {m.metadata.key}: {m.memory}"
-                for m in ranked_memories
-            ]
+            [f"[{m.id}] {m.metadata.key}: {m.memory}" for m in ranked_memories]
         )
         prompt = prompt_template.substitute(task=query, detailed_memory_list=memory_detailed_str)
 

memos/memories/textual/tree_text_memory/retrieve/searcher.py

@@ -8,6 +8,7 @@ from memos.graph_dbs.factory import Neo4jGraphDB
 from memos.llms.factory import OllamaLLM, OpenAILLM
 from memos.memories.textual.item import SearchedTreeNodeTextualMemoryMetadata, TextualMemoryItem
 
+from .internet_retriever_factory import InternetRetrieverFactory
 from .reasoner import MemoryReasoner
 from .recall import GraphMemoryRetriever
 from .reranker import MemoryReranker
@@ -20,6 +21,7 @@ class Searcher:
         dispatcher_llm: OpenAILLM | OllamaLLM,
         graph_store: Neo4jGraphDB,
         embedder: OllamaEmbedder,
+        internet_retriever: InternetRetrieverFactory | None = None,
     ):
         self.graph_store = graph_store
         self.embedder = embedder
@@ -29,6 +31,9 @@ class Searcher:
         self.reranker = MemoryReranker(dispatcher_llm, self.embedder)
         self.reasoner = MemoryReasoner(dispatcher_llm)
 
+        # Create internet retriever from config if provided
+        self.internet_retriever = internet_retriever
+
     def search(
         self, query: str, top_k: int, info=None, mode: str = "fast", memory_type: str = "All"
     ) -> list[TextualMemoryItem]:
@@ -50,7 +55,19 @@ class Searcher:
         """
 
         # Step 1: Parse task structure into topic, concept, and fact levels
-        parsed_goal = self.task_goal_parser.parse(query)
+        context = []
+        if mode == "fine":
+            query_embedding = self.embedder.embed([query])[0]
+            related_node_ids = self.graph_store.search_by_embedding(query_embedding, top_k=top_k)
+            related_nodes = [
+                self.graph_store.get_node(related_node["id"]) for related_node in related_node_ids
+            ]
+
+            context = [related_node["memory"] for related_node in related_nodes]
+            context = list(set(context))
+
+        # Step 1a: Parse task structure into topic, concept, and fact levels
+        parsed_goal = self.task_goal_parser.parse(query, "\n".join(context))
 
         if parsed_goal.memories:
             query_embedding = self.embedder.embed(list({query, *parsed_goal.memories}))
@@ -114,14 +131,39 @@ class Searcher:
             )
             return ranked_memories
 
-        # Step 3: Parallel execution of both paths
-        with concurrent.futures.ThreadPoolExecutor(max_workers=2) as executor:
+        # Step 2c: Internet retrieval (Path C)
+        def retrieve_from_internet():
+            """
+            Retrieve information from the internet using Google Custom Search API.
+            """
+            if not self.internet_retriever:
+                return []
+            if memory_type not in ["All"]:
+                return []
+            internet_items = self.internet_retriever.retrieve_from_internet(
+                query=query, top_k=top_k, parsed_goal=parsed_goal
+            )
+
+            # Convert to the format expected by reranker
+            ranked_memories = self.reranker.rerank(
+                query=query,
+                query_embedding=query_embedding[0],
+                graph_results=internet_items,
+                top_k=top_k * 2,
+                parsed_goal=parsed_goal,
+            )
+            return ranked_memories
+
+        # Step 3: Parallel execution of all paths
+        with concurrent.futures.ThreadPoolExecutor(max_workers=3) as executor:
             future_working = executor.submit(retrieve_from_working_memory)
             future_hybrid = executor.submit(retrieve_ranked_long_term_and_user)
+            future_internet = executor.submit(retrieve_from_internet)
 
             working_results = future_working.result()
             hybrid_results = future_hybrid.result()
-            searched_res = working_results + hybrid_results
+            internet_results = future_internet.result()
+            searched_res = working_results + hybrid_results + internet_results
 
         # Deduplicate by item.memory, keep higher score
         deduped_result = {}

memos/memories/textual/tree_text_memory/retrieve/task_goal_parser.py

@@ -31,7 +31,7 @@ class TaskGoalParser:
         elif self.mode == "fine":
             if not self.llm:
                 raise ValueError("LLM not provided for slow mode.")
-            return self._parse_fine(task_description)
+            return self._parse_fine(task_description, context)
         else:
             raise ValueError(f"Unknown mode: {self.mode}")
 
@@ -43,11 +43,11 @@ class TaskGoalParser:
             memories=[task_description], keys=[task_description], tags=[], goal_type="default"
         )
 
-    def _parse_fine(self, query: str) -> ParsedTaskGoal:
+    def _parse_fine(self, query: str, context: str = "") -> ParsedTaskGoal:
         """
         Slow mode: LLM structured parse.
         """
-        prompt = Template(TASK_PARSE_PROMPT).substitute(task=query.strip(), context="")
+        prompt = Template(TASK_PARSE_PROMPT).substitute(task=query.strip(), context=context)
         response = self.llm.generate(messages=[{"role": "user", "content": prompt}])
         return self._parse_response(response)