mentedb-langchain 0.1.0__py3-none-any.whl

mentedb_langchain/__init__.py

@@ -0,0 +1,5 @@
+from mentedb_langchain.memory import MenteDBMemory
+from mentedb_langchain.retriever import MenteDBRetriever
+from mentedb_langchain.chat_history import MenteDBChatHistory
+
+__all__ = ["MenteDBMemory", "MenteDBRetriever", "MenteDBChatHistory"]

mentedb_langchain/chat_history.py

@@ -0,0 +1,58 @@
+"""LangChain chat history backed by MenteDB."""
+from typing import List, Optional
+
+from mentedb import MenteDB
+
+
+class MenteDBChatHistory:
+    """Stores chat message history in MenteDB with persistent recall.
+
+    Each message is stored as an episodic memory, enabling semantic
+    search across conversation history and cross-session continuity.
+
+    Usage:
+        from mentedb_langchain import MenteDBChatHistory
+
+        history = MenteDBChatHistory(
+            session_id="session-123",
+            data_dir="./agent-memory",
+        )
+
+        history.add_user_message("What database should I use?")
+        history.add_ai_message("I recommend PostgreSQL.")
+
+        messages = history.messages
+    """
+
+    def __init__(self, session_id: str, data_dir: str = "./mentedb-data",
+                 agent_id: Optional[str] = None):
+        self.session_id = session_id
+        self.data_dir = data_dir
+        self.agent_id = agent_id
+        self._db = MenteDB(data_dir)
+        self._messages: list = []
+
+    @property
+    def messages(self) -> list:
+        return self._messages
+
+    def add_user_message(self, message: str) -> None:
+        self._messages.append({"role": "user", "content": message})
+        self._db.store(
+            f"[{self.session_id}] User: {message}",
+            memory_type="episodic",
+            agent_id=self.agent_id,
+            tags=["chat_history", self.session_id],
+        )
+
+    def add_ai_message(self, message: str) -> None:
+        self._messages.append({"role": "assistant", "content": message})
+        self._db.store(
+            f"[{self.session_id}] Assistant: {message}",
+            memory_type="episodic",
+            agent_id=self.agent_id,
+            tags=["chat_history", self.session_id],
+        )
+
+    def clear(self) -> None:
+        self._messages.clear()

mentedb_langchain/memory.py

@@ -0,0 +1,63 @@
+"""LangChain memory backed by MenteDB."""
+from typing import Any, Dict, List, Optional
+
+from mentedb import MenteDB
+
+
+class MenteDBMemory:
+    """LangChain compatible memory that stores conversation context in MenteDB.
+
+    Usage with LangChain:
+        from mentedb_langchain import MenteDBMemory
+
+        memory = MenteDBMemory(data_dir="./agent-memory", agent_id="my-agent")
+
+        memory.save_context(
+            inputs={"input": "What database should I use?"},
+            outputs={"output": "I recommend PostgreSQL for your use case."}
+        )
+
+        context = memory.load_memory_variables({"input": "Tell me more about that database"})
+    """
+
+    memory_key: str = "history"
+
+    def __init__(self, data_dir: str = "./mentedb-data", agent_id: Optional[str] = None,
+                 token_budget: int = 4096, return_messages: bool = False):
+        self.data_dir = data_dir
+        self.agent_id = agent_id
+        self.token_budget = token_budget
+        self.return_messages = return_messages
+        self._db = MenteDB(data_dir)
+
+    @property
+    def memory_variables(self) -> List[str]:
+        return [self.memory_key]
+
+    def load_memory_variables(self, inputs: Dict[str, Any]) -> Dict[str, Any]:
+        """Load relevant memories based on the current input."""
+        query = inputs.get("input", "")
+        if not query:
+            return {self.memory_key: ""}
+        results = self._db.search_text(query, k=10)
+        if not results:
+            return {self.memory_key: ""}
+        texts = []
+        for r in results:
+            mem = self._db.get_memory(r.id)
+            if mem:
+                texts.append(mem["content"])
+        return {self.memory_key: "\n".join(texts)}
+
+    def save_context(self, inputs: Dict[str, Any], outputs: Dict[str, str]) -> None:
+        """Save a conversation turn as episodic memory."""
+        input_text = inputs.get("input", "")
+        output_text = outputs.get("output", "")
+        content = f"User: {input_text}\nAssistant: {output_text}"
+        self._db.store(content, memory_type="episodic", agent_id=self.agent_id)
+
+    def clear(self) -> None:
+        """Clear all memories by closing and reopening."""
+        self._db.close()
+        self._db = MenteDB(self.data_dir)
+

mentedb_langchain/retriever.py

@@ -0,0 +1,53 @@
+"""LangChain retriever backed by MenteDB vector search."""
+from typing import List, Optional
+
+from mentedb import MenteDB
+
+
+class MenteDBRetriever:
+    """LangChain compatible retriever using MenteDB hybrid search.
+
+    Combines vector similarity, tag filtering, and temporal relevance
+    in a single retrieval call.
+
+    Usage:
+        from mentedb_langchain import MenteDBRetriever
+
+        retriever = MenteDBRetriever(
+            data_dir="./agent-memory",
+            k=10,
+            tags=["backend", "architecture"],
+        )
+
+        docs = retriever.get_relevant_documents("database migration strategy")
+    """
+
+    def __init__(self, data_dir: str = "./mentedb-data", k: int = 10,
+                 tags: Optional[List[str]] = None, agent_id: Optional[str] = None):
+        self.data_dir = data_dir
+        self.k = k
+        self.tags = tags
+        self.agent_id = agent_id
+        self._db = MenteDB(data_dir)
+
+    def get_relevant_documents(self, query: str) -> list:
+        """Retrieve relevant memories as dicts with id, content, and score."""
+        results = self._db.search_text(query, k=self.k, tags=self.tags)
+        docs = []
+        for r in results:
+            mem = self._db.get_memory(r.id)
+            if mem:
+                docs.append({
+                    "page_content": mem["content"],
+                    "metadata": {
+                        "id": r.id,
+                        "score": r.score,
+                        "memory_type": mem.get("memory_type", ""),
+                        "tags": mem.get("tags", []),
+                    },
+                })
+        return docs
+
+    async def aget_relevant_documents(self, query: str) -> list:
+        """Async version of get_relevant_documents."""
+        return self.get_relevant_documents(query)

mentedb_langchain-0.1.0.dist-info/METADATA

@@ -0,0 +1,8 @@
+Metadata-Version: 2.4
+Name: mentedb-langchain
+Version: 0.1.0
+Summary: MenteDB integration for LangChain and LangGraph
+License-Expression: Apache-2.0
+Requires-Python: >=3.9
+Requires-Dist: langchain-core>=0.3
+Requires-Dist: mentedb>=0.7.0

mentedb_langchain-0.1.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+mentedb_langchain/__init__.py,sha256=1sdnbAnHFPGsjgEAcb0zATsWEb07w8uzr22XyiUSTmk,241
+mentedb_langchain/chat_history.py,sha256=uy6d5Cx_Vmv4j6vADbRqvEHl1bXwBPu98SPCmMZC8Kw,1821
+mentedb_langchain/memory.py,sha256=MmOcr85AxzEaYMIFNmVKjgp2NkEtRxru0ocjQYFXPQA,2251
+mentedb_langchain/retriever.py,sha256=NbIsZQwUs4VsFPAKD4NUe_Zhmi08qI3L2mmJ9sCsx2o,1792
+mentedb_langchain-0.1.0.dist-info/METADATA,sha256=dANlfeZj4C6qszEO3sERpSrZBmeIq_i-lBt1bqq0z2c,237
+mentedb_langchain-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+mentedb_langchain-0.1.0.dist-info/RECORD,,

mentedb_langchain-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any