langchain-synapse 0.1.0__tar.gz

langchain_synapse-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024-2026 Raghuram Parvataneni
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

langchain_synapse-0.1.0/PKG-INFO

@@ -0,0 +1,104 @@
+Metadata-Version: 2.4
+Name: langchain-synapse
+Version: 0.1.0
+Summary: An integration package connecting Synapse memory and LangChain. Privacy-first, zero API calls, pure Python.
+Project-URL: Homepage, https://github.com/raghuram369/synapse
+Project-URL: Repository, https://github.com/raghuram369/synapse
+Project-URL: Issues, https://github.com/raghuram369/synapse/issues
+License: MIT
+License-File: LICENSE
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Requires-Dist: langchain-core<1.0.0,>=0.3.0
+Requires-Dist: synapse-ai-memory>=0.3.0
+Description-Content-Type: text/markdown
+
+# langchain-synapse
+
+An integration package connecting [Synapse](https://github.com/raghuram369/synapse) memory and [LangChain](https://github.com/langchain-ai/langchain).
+
+**Privacy-first AI memory** — all data stays local. Zero API calls for storage. Zero external dependencies beyond LangChain and Synapse.
+
+## Installation
+
+```bash
+pip install langchain-synapse
+```
+
+## Components
+
+### SynapseMemory
+
+Drop-in `BaseMemory` implementation for any LangChain chain:
+
+```python
+from langchain_synapse import SynapseMemory
+from synapse import Synapse
+
+syn = Synapse("./agent_memory")
+memory = SynapseMemory(synapse=syn)
+
+# Use with any chain
+chain = prompt | llm
+chain.invoke({"input": "hello"}, config={"memory": memory})
+```
+
+### SynapseChatMessageHistory
+
+Persistent chat history with semantic recall:
+
+```python
+from langchain_synapse import SynapseChatMessageHistory
+from synapse import Synapse
+
+syn = Synapse("./chat_memory")
+history = SynapseChatMessageHistory(synapse=syn, session_id="user-123")
+
+history.add_user_message("I love Italian food")
+history.add_ai_message("Great! Any favorite dish?")
+
+# Semantic search — find relevant messages, not just recent ones
+relevant = history.search("What cuisine do they prefer?")
+```
+
+### SynapseRetriever
+
+Use Synapse as a retriever in RAG pipelines:
+
+```python
+from langchain_synapse import SynapseRetriever
+from synapse import Synapse
+
+syn = Synapse("./knowledge_base")
+syn.remember("Python was created by Guido van Rossum")
+syn.remember("Rust was created by Graydon Hoare at Mozilla")
+
+retriever = SynapseRetriever(synapse=syn, k=5)
+
+# Use in a RAG chain
+from langchain_core.runnables import RunnablePassthrough
+chain = (
+    {"context": retriever, "question": RunnablePassthrough()}
+    | prompt
+    | llm
+)
+```
+
+## Why Synapse?
+
+- **🔒 Privacy-first**: All memory stays on your machine. No cloud. No API calls for storage.
+- **🧠 Neuroscience-inspired**: Memory strengthening, decay, and semantic recall — not just vector similarity.
+- **⚡ Zero dependencies**: Synapse itself is pure Python with no external dependencies.
+- **📦 Portable**: `.synapse` files can be shared, versioned, and federated across agents.
+
+## License
+
+MIT

langchain_synapse-0.1.0/README.md

@@ -0,0 +1,81 @@
+# langchain-synapse
+
+An integration package connecting [Synapse](https://github.com/raghuram369/synapse) memory and [LangChain](https://github.com/langchain-ai/langchain).
+
+**Privacy-first AI memory** — all data stays local. Zero API calls for storage. Zero external dependencies beyond LangChain and Synapse.
+
+## Installation
+
+```bash
+pip install langchain-synapse
+```
+
+## Components
+
+### SynapseMemory
+
+Drop-in `BaseMemory` implementation for any LangChain chain:
+
+```python
+from langchain_synapse import SynapseMemory
+from synapse import Synapse
+
+syn = Synapse("./agent_memory")
+memory = SynapseMemory(synapse=syn)
+
+# Use with any chain
+chain = prompt | llm
+chain.invoke({"input": "hello"}, config={"memory": memory})
+```
+
+### SynapseChatMessageHistory
+
+Persistent chat history with semantic recall:
+
+```python
+from langchain_synapse import SynapseChatMessageHistory
+from synapse import Synapse
+
+syn = Synapse("./chat_memory")
+history = SynapseChatMessageHistory(synapse=syn, session_id="user-123")
+
+history.add_user_message("I love Italian food")
+history.add_ai_message("Great! Any favorite dish?")
+
+# Semantic search — find relevant messages, not just recent ones
+relevant = history.search("What cuisine do they prefer?")
+```
+
+### SynapseRetriever
+
+Use Synapse as a retriever in RAG pipelines:
+
+```python
+from langchain_synapse import SynapseRetriever
+from synapse import Synapse
+
+syn = Synapse("./knowledge_base")
+syn.remember("Python was created by Guido van Rossum")
+syn.remember("Rust was created by Graydon Hoare at Mozilla")
+
+retriever = SynapseRetriever(synapse=syn, k=5)
+
+# Use in a RAG chain
+from langchain_core.runnables import RunnablePassthrough
+chain = (
+    {"context": retriever, "question": RunnablePassthrough()}
+    | prompt
+    | llm
+)
+```
+
+## Why Synapse?
+
+- **🔒 Privacy-first**: All memory stays on your machine. No cloud. No API calls for storage.
+- **🧠 Neuroscience-inspired**: Memory strengthening, decay, and semantic recall — not just vector similarity.
+- **⚡ Zero dependencies**: Synapse itself is pure Python with no external dependencies.
+- **📦 Portable**: `.synapse` files can be shared, versioned, and federated across agents.
+
+## License
+
+MIT

langchain_synapse-0.1.0/langchain_synapse/__init__.py

@@ -0,0 +1,11 @@
+"""LangChain integration for Synapse — privacy-first memory for AI agents."""
+
+from langchain_synapse.chat_history import SynapseChatMessageHistory
+from langchain_synapse.memory import SynapseMemory
+from langchain_synapse.retriever import SynapseRetriever
+
+__all__ = [
+    "SynapseChatMessageHistory",
+    "SynapseMemory",
+    "SynapseRetriever",
+]

langchain_synapse-0.1.0/langchain_synapse/chat_history.py

@@ -0,0 +1,101 @@
+"""SynapseChatMessageHistory — LangChain chat history backed by Synapse.
+
+Privacy-first: all messages stay local. No cloud storage.
+"""
+
+from __future__ import annotations
+
+import time
+from typing import Any, Dict, List, Optional, Sequence
+
+from langchain_core.chat_history import BaseChatMessageHistory
+from langchain_core.messages import AIMessage, BaseMessage, HumanMessage, SystemMessage
+from synapse import Synapse
+
+
+class SynapseChatMessageHistory(BaseChatMessageHistory):
+    """Persistent chat message history using Synapse as the backend.
+
+    Unlike simple list-based histories, Synapse provides semantic recall —
+    relevant past messages surface automatically based on context.
+
+    Example::
+
+        from synapse import Synapse
+        from langchain_synapse import SynapseChatMessageHistory
+
+        syn = Synapse("./chat_memory")
+        history = SynapseChatMessageHistory(synapse=syn, session_id="user-123")
+
+        history.add_user_message("I love Italian food")
+        history.add_ai_message("Great! Do you have a favorite dish?")
+    """
+
+    def __init__(
+        self,
+        synapse: Optional[Synapse] = None,
+        path: str = ":memory:",
+        session_id: str = "default",
+    ):
+        self.synapse = synapse or Synapse(path)
+        self.session_id = session_id
+
+    def _make_metadata(self, role: str) -> Dict[str, Any]:
+        return {
+            "role": role,
+            "session_id": self.session_id,
+            "source": "langchain_chat_history",
+            "timestamp": time.time(),
+        }
+
+    def add_message(self, message: BaseMessage) -> None:
+        """Add a LangChain BaseMessage to history."""
+        if isinstance(message, HumanMessage):
+            role = "human"
+        elif isinstance(message, AIMessage):
+            role = "ai"
+        elif isinstance(message, SystemMessage):
+            role = "system"
+        else:
+            role = "unknown"
+
+        self.synapse.remember(
+            str(message.content),
+            memory_type="observation",
+            metadata=self._make_metadata(role),
+            episode=f"chat-{self.session_id}",
+        )
+
+    @property
+    def messages(self) -> List[BaseMessage]:
+        """Return all messages in this session, ordered by time."""
+        all_memories = self.synapse.recall("", limit=10000)
+        session_memories = [
+            m for m in all_memories
+            if (m.metadata or {}).get("session_id") == self.session_id
+        ]
+        session_memories.sort(key=lambda m: m.created_at)
+
+        messages: List[BaseMessage] = []
+        for mem in session_memories:
+            role = (mem.metadata or {}).get("role", "human")
+            if role == "ai":
+                messages.append(AIMessage(content=mem.content))
+            elif role == "system":
+                messages.append(SystemMessage(content=mem.content))
+            else:
+                messages.append(HumanMessage(content=mem.content))
+        return messages
+
+    def search(self, query: str, limit: int = 5) -> List[Any]:
+        """Semantic search across chat history — Synapse's superpower."""
+        results = self.synapse.recall(query, limit=limit)
+        return [m for m in results
+                if (m.metadata or {}).get("session_id") == self.session_id]
+
+    def clear(self) -> None:
+        """Clear all messages in this session."""
+        all_memories = self.synapse.recall("", limit=10000)
+        for mem in all_memories:
+            if (mem.metadata or {}).get("session_id") == self.session_id:
+                self.synapse.forget(mem.id)

langchain_synapse-0.1.0/langchain_synapse/checkpointer.py

@@ -0,0 +1,189 @@
+"""SynapseCheckpointer — LangGraph checkpoint persistence backed by Synapse.
+
+Saves and restores graph state between invocations.
+All data stays local.
+"""
+
+from __future__ import annotations
+
+import json
+import time
+from typing import Any, Dict, Iterator, Optional, Sequence, Tuple
+
+from synapse import Synapse
+
+try:
+    from langgraph.checkpoint.base import (
+        BaseCheckpointSaver,
+        Checkpoint,
+        CheckpointMetadata,
+        CheckpointTuple,
+    )
+
+    _HAS_LANGGRAPH = True
+except ImportError:
+    _HAS_LANGGRAPH = False
+    BaseCheckpointSaver = object  # type: ignore
+
+
+class SynapseCheckpointer(BaseCheckpointSaver):  # type: ignore[misc]
+    """LangGraph-compatible checkpointer using Synapse for persistence.
+
+    Example::
+
+        from synapse import Synapse
+        from langchain_synapse import SynapseCheckpointer
+
+        syn = Synapse("./agent_state")
+        checkpointer = SynapseCheckpointer(synapse=syn)
+        graph = builder.compile(checkpointer=checkpointer)
+    """
+
+    def __init__(self, synapse: Optional[Synapse] = None, path: str = ":memory:"):
+        if _HAS_LANGGRAPH:
+            super().__init__()
+        self.synapse = synapse or Synapse(path)
+        self._index: Dict[str, list] = {}
+        self._rebuild_index()
+
+    def _rebuild_index(self) -> None:
+        all_memories = self.synapse.recall("", limit=10000)
+        for mem in all_memories:
+            meta = mem.metadata or {}
+            if meta.get("source") == "langgraph_checkpoint":
+                thread_id = meta.get("thread_id", "default")
+                checkpoint_id = meta.get("checkpoint_id", "")
+                self._index.setdefault(thread_id, []).append(
+                    (checkpoint_id, mem.id, mem.created_at)
+                )
+        for thread_id in self._index:
+            self._index[thread_id].sort(key=lambda x: x[2])
+
+    def _make_checkpoint_id(self, thread_id: str) -> str:
+        count = len(self._index.get(thread_id, []))
+        return f"{thread_id}:{count}:{time.time()}"
+
+    def put(
+        self,
+        config: Dict[str, Any],
+        checkpoint: Dict[str, Any],
+        metadata: Optional[Dict[str, Any]] = None,
+        new_versions: Optional[Any] = None,
+    ) -> Dict[str, Any]:
+        configurable = config.get("configurable", {})
+        thread_id = configurable.get("thread_id", "default")
+        checkpoint_ns = configurable.get("checkpoint_ns", "")
+        checkpoint_id = self._make_checkpoint_id(thread_id)
+
+        content = json.dumps(checkpoint, default=str)
+        mem = self.synapse.remember(
+            content,
+            memory_type="fact",
+            metadata={
+                "source": "langgraph_checkpoint",
+                "thread_id": thread_id,
+                "checkpoint_ns": checkpoint_ns,
+                "checkpoint_id": checkpoint_id,
+                "checkpoint_metadata": json.dumps(metadata or {}, default=str),
+            },
+            deduplicate=False,
+        )
+        self._index.setdefault(thread_id, []).append(
+            (checkpoint_id, mem.id, mem.created_at)
+        )
+        return {
+            "configurable": {
+                "thread_id": thread_id,
+                "checkpoint_ns": checkpoint_ns,
+                "checkpoint_id": checkpoint_id,
+            }
+        }
+
+    def put_writes(
+        self,
+        config: Dict[str, Any],
+        writes: Sequence[Tuple[str, Any]],
+        task_id: str,
+    ) -> None:
+        configurable = config.get("configurable", {})
+        thread_id = configurable.get("thread_id", "default")
+        checkpoint_id = configurable.get("checkpoint_id", "")
+        content = json.dumps({"writes": writes, "task_id": task_id}, default=str)
+        self.synapse.remember(
+            content,
+            memory_type="fact",
+            metadata={
+                "source": "langgraph_writes",
+                "thread_id": thread_id,
+                "checkpoint_id": checkpoint_id,
+                "task_id": task_id,
+            },
+            deduplicate=False,
+        )
+
+    def get_tuple(self, config: Dict[str, Any]) -> Optional[Any]:
+        configurable = config.get("configurable", {})
+        thread_id = configurable.get("thread_id", "default")
+        checkpoint_id = configurable.get("checkpoint_id")
+        entries = self._index.get(thread_id, [])
+        if not entries:
+            return None
+
+        target = (
+            next((e for e in entries if e[0] == checkpoint_id), None)
+            if checkpoint_id
+            else entries[-1]
+        )
+        if not target:
+            return None
+
+        cp_id, mem_id, _ = target
+        memories = self.synapse.recall("", limit=10000)
+        mem = next((m for m in memories if m.id == mem_id), None)
+        if not mem:
+            return None
+
+        checkpoint = json.loads(mem.content)
+        meta = mem.metadata or {}
+        checkpoint_metadata = json.loads(meta.get("checkpoint_metadata", "{}"))
+
+        if _HAS_LANGGRAPH:
+            return CheckpointTuple(
+                config={
+                    "configurable": {
+                        "thread_id": thread_id,
+                        "checkpoint_ns": meta.get("checkpoint_ns", ""),
+                        "checkpoint_id": cp_id,
+                    }
+                },
+                checkpoint=checkpoint,
+                metadata=checkpoint_metadata,
+                parent_config=None,
+                pending_writes=[],
+            )
+        return {"config": config, "checkpoint": checkpoint, "metadata": checkpoint_metadata}
+
+    def list(
+        self,
+        config: Optional[Dict[str, Any]] = None,
+        *,
+        filter: Optional[Dict[str, Any]] = None,
+        before: Optional[Dict[str, Any]] = None,
+        limit: Optional[int] = None,
+    ) -> Iterator[Any]:
+        if config:
+            thread_id = config.get("configurable", {}).get("thread_id", "default")
+            entries = self._index.get(thread_id, [])
+        else:
+            entries = [e for thread_entries in self._index.values() for e in thread_entries]
+            thread_id = "default"
+
+        entries.sort(key=lambda x: x[2], reverse=True)
+        if limit:
+            entries = entries[:limit]
+        for cp_id, mem_id, created_at in entries:
+            result = self.get_tuple(
+                {"configurable": {"thread_id": thread_id, "checkpoint_id": cp_id}}
+            )
+            if result:
+                yield result

langchain_synapse-0.1.0/langchain_synapse/memory.py

@@ -0,0 +1,98 @@
+"""SynapseMemory — LangChain BaseMemory backed by Synapse.
+
+Privacy-first: all memory stays local. No API calls for storage.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional
+
+from langchain_core.memory import BaseMemory
+from synapse import Synapse
+
+
+class SynapseMemory(BaseMemory):
+    """LangChain-compatible memory backed by Synapse.
+
+    Stores conversation history and relevant facts in a local Synapse
+    database. Recall is semantic — not just last-N messages.
+
+    Example::
+
+        from synapse import Synapse
+        from langchain_synapse import SynapseMemory
+
+        syn = Synapse("./agent_memory")
+        memory = SynapseMemory(synapse=syn)
+    """
+
+    synapse: Any  # Synapse instance
+    memory_key: str = "history"
+    input_key: Optional[str] = None
+    output_key: Optional[str] = None
+    recall_limit: int = 10
+    store_inputs: bool = True
+    store_outputs: bool = True
+    return_messages: bool = False
+
+    class Config:
+        arbitrary_types_allowed = True
+
+    def __init__(self, synapse: Optional[Synapse] = None, path: str = ":memory:", **kwargs: Any):
+        super().__init__(synapse=synapse or Synapse(path), **kwargs)
+
+    @property
+    def memory_variables(self) -> List[str]:
+        return [self.memory_key]
+
+    def load_memory_variables(self, inputs: Dict[str, Any]) -> Dict[str, Any]:
+        """Recall relevant memories based on the current input."""
+        context_parts = [v for v in inputs.values() if isinstance(v, str)]
+        context = " ".join(context_parts) if context_parts else ""
+
+        memories = self.synapse.recall(context, limit=self.recall_limit)
+
+        if self.return_messages:
+            from langchain_core.messages import AIMessage, HumanMessage
+
+            messages = []
+            for mem in memories:
+                role = (mem.metadata or {}).get("role", "human")
+                if role == "ai":
+                    messages.append(AIMessage(content=mem.content))
+                else:
+                    messages.append(HumanMessage(content=mem.content))
+            return {self.memory_key: messages}
+
+        formatted = "\n".join(f"- {m.content}" for m in memories)
+        return {self.memory_key: formatted}
+
+    def save_context(self, inputs: Dict[str, Any], outputs: Dict[str, str]) -> None:
+        """Store the conversation turn in Synapse."""
+        if self.store_inputs:
+            input_key = self.input_key or next(iter(inputs), None)
+            if input_key and input_key in inputs:
+                value = inputs[input_key]
+                if isinstance(value, str) and value.strip():
+                    self.synapse.remember(
+                        value,
+                        memory_type="observation",
+                        metadata={"role": "human", "source": "langchain"},
+                    )
+
+        if self.store_outputs:
+            output_key = self.output_key or next(iter(outputs), None)
+            if output_key and output_key in outputs:
+                value = outputs[output_key]
+                if isinstance(value, str) and value.strip():
+                    self.synapse.remember(
+                        value,
+                        memory_type="observation",
+                        metadata={"role": "ai", "source": "langchain"},
+                    )
+
+    def clear(self) -> None:
+        """Clear all memories."""
+        all_memories = self.synapse.recall("", limit=10000)
+        for mem in all_memories:
+            self.synapse.forget(mem.id)

langchain_synapse-0.1.0/langchain_synapse/retriever.py

@@ -0,0 +1,78 @@
+"""SynapseRetriever — LangChain BaseRetriever backed by Synapse.
+
+Privacy-first: all retrieval is local. No vector DB API calls.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional
+
+from langchain_core.callbacks import CallbackManagerForRetrieverRun
+from langchain_core.documents import Document
+from langchain_core.retrievers import BaseRetriever
+from synapse import Synapse
+
+
+class SynapseRetriever(BaseRetriever):
+    """LangChain-compatible retriever using Synapse's semantic recall.
+
+    Synapse combines BM25, concept graphs, and optional local embeddings
+    for retrieval — all running locally with zero external API calls.
+
+    Example::
+
+        from synapse import Synapse
+        from langchain_synapse import SynapseRetriever
+
+        syn = Synapse("./knowledge_base")
+        syn.remember("Python was created by Guido van Rossum")
+
+        retriever = SynapseRetriever(synapse=syn, k=5)
+        docs = retriever.invoke("Who created Python?")
+    """
+
+    synapse: Any  # Synapse instance
+    k: int = 5
+    memory_type: Optional[str] = None
+    min_strength: float = 0.01
+    metadata_filter: Dict[str, Any] = {}
+
+    class Config:
+        arbitrary_types_allowed = True
+
+    def __init__(self, synapse: Optional[Synapse] = None, path: str = ":memory:", **kwargs: Any):
+        super().__init__(synapse=synapse or Synapse(path), **kwargs)
+
+    def _get_relevant_documents(
+        self, query: str, *, run_manager: CallbackManagerForRetrieverRun
+    ) -> List[Document]:
+        """Retrieve relevant documents from Synapse."""
+        memories = self.synapse.recall(
+            query,
+            limit=self.k,
+            memory_type=self.memory_type,
+            min_strength=self.min_strength,
+        )
+
+        if self.metadata_filter:
+            memories = [
+                m for m in memories
+                if all(
+                    (m.metadata or {}).get(k) == v
+                    for k, v in self.metadata_filter.items()
+                )
+            ]
+
+        return [
+            Document(
+                page_content=mem.content,
+                metadata={
+                    "memory_id": mem.id,
+                    "memory_type": mem.memory_type,
+                    "strength": mem.effective_strength,
+                    "created_at": mem.created_at,
+                    **(mem.metadata or {}),
+                },
+            )
+            for mem in memories
+        ]

langchain_synapse-0.1.0/pyproject.toml

@@ -0,0 +1,39 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "langchain-synapse"
+version = "0.1.0"
+description = "An integration package connecting Synapse memory and LangChain. Privacy-first, zero API calls, pure Python."
+license = { text = "MIT" }
+readme = "README.md"
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+requires-python = ">=3.10"
+dependencies = [
+    "langchain-core>=0.3.0,<1.0.0",
+    "synapse-ai-memory>=0.3.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/raghuram369/synapse"
+Repository = "https://github.com/raghuram369/synapse"
+Issues = "https://github.com/raghuram369/synapse/issues"
+
+[dependency-groups]
+test = [
+    "pytest>=7.3.0,<9.0.0",
+    "pytest-asyncio>=0.21.1,<1.0.0",
+    "langchain-core",
+]
+dev = ["langchain-core"]

langchain_synapse-0.1.0/tests/test_chat_history.py

@@ -0,0 +1,43 @@
+"""Tests for SynapseChatMessageHistory."""
+
+from langchain_core.messages import AIMessage, HumanMessage
+from synapse import Synapse
+from langchain_synapse import SynapseChatMessageHistory
+
+
+def test_add_and_retrieve_messages():
+    syn = Synapse(":memory:")
+    history = SynapseChatMessageHistory(synapse=syn, session_id="test")
+    history.add_user_message("Hello")
+    history.add_ai_message("Hi there!")
+    messages = history.messages
+    assert len(messages) == 2
+    assert isinstance(messages[0], HumanMessage)
+    assert isinstance(messages[1], AIMessage)
+
+
+def test_search():
+    syn = Synapse(":memory:")
+    history = SynapseChatMessageHistory(synapse=syn, session_id="test")
+    history.add_user_message("I love Italian food")
+    history.add_user_message("The weather is nice today")
+    results = history.search("cuisine preferences")
+    assert len(results) > 0
+
+
+def test_clear():
+    syn = Synapse(":memory:")
+    history = SynapseChatMessageHistory(synapse=syn, session_id="test")
+    history.add_user_message("Hello")
+    history.clear()
+    assert len(history.messages) == 0
+
+
+def test_session_isolation():
+    syn = Synapse(":memory:")
+    h1 = SynapseChatMessageHistory(synapse=syn, session_id="s1")
+    h2 = SynapseChatMessageHistory(synapse=syn, session_id="s2")
+    h1.add_user_message("Session 1 message")
+    h2.add_user_message("Session 2 message")
+    assert len(h1.messages) == 1
+    assert len(h2.messages) == 1

langchain_synapse-0.1.0/tests/test_checkpointer.py

@@ -0,0 +1,31 @@
+"""Tests for SynapseCheckpointer."""
+
+from synapse import Synapse
+from langchain_synapse.checkpointer import SynapseCheckpointer
+
+
+def test_put_and_get():
+    syn = Synapse(":memory:")
+    cp = SynapseCheckpointer(synapse=syn)
+    config = {"configurable": {"thread_id": "t1"}}
+    checkpoint = {"v": 1, "ts": "2024-01-01", "channel_values": {"messages": []}}
+
+    result_config = cp.put(config, checkpoint, metadata={"step": 0})
+    assert "configurable" in result_config
+    assert result_config["configurable"]["thread_id"] == "t1"
+
+    # Retrieve
+    tup = cp.get_tuple(config)
+    assert tup is not None
+
+
+def test_list_checkpoints():
+    syn = Synapse(":memory:")
+    cp = SynapseCheckpointer(synapse=syn)
+    config = {"configurable": {"thread_id": "t1"}}
+
+    cp.put(config, {"v": 1, "ts": "1"}, metadata={"step": 0})
+    cp.put(config, {"v": 1, "ts": "2"}, metadata={"step": 1})
+
+    items = list(cp.list(config))
+    assert len(items) == 2

langchain_synapse-0.1.0/tests/test_memory.py

@@ -0,0 +1,36 @@
+"""Tests for SynapseMemory."""
+
+from synapse import Synapse
+from langchain_synapse import SynapseMemory
+
+
+def test_memory_variables():
+    mem = SynapseMemory(synapse=Synapse(":memory:"))
+    assert mem.memory_variables == ["history"]
+
+
+def test_save_and_load():
+    syn = Synapse(":memory:")
+    mem = SynapseMemory(synapse=syn)
+    mem.save_context({"input": "I like pizza"}, {"output": "Great choice!"})
+    result = mem.load_memory_variables({"input": "food preferences"})
+    assert "history" in result
+    assert len(result["history"]) > 0
+
+
+def test_clear():
+    syn = Synapse(":memory:")
+    mem = SynapseMemory(synapse=syn)
+    mem.save_context({"input": "test"}, {"output": "response"})
+    mem.clear()
+    result = mem.load_memory_variables({"input": "test"})
+    assert result["history"] == ""
+
+
+def test_return_messages():
+    syn = Synapse(":memory:")
+    mem = SynapseMemory(synapse=syn, return_messages=True)
+    mem.save_context({"input": "hello"}, {"output": "hi there"})
+    result = mem.load_memory_variables({"input": "greeting"})
+    messages = result["history"]
+    assert len(messages) > 0

langchain_synapse-0.1.0/tests/test_retriever.py

@@ -0,0 +1,23 @@
+"""Tests for SynapseRetriever."""
+
+from langchain_core.documents import Document
+from synapse import Synapse
+from langchain_synapse import SynapseRetriever
+
+
+def test_retrieve_documents():
+    syn = Synapse(":memory:")
+    syn.remember("Python was created by Guido van Rossum")
+    syn.remember("JavaScript was created by Brendan Eich")
+
+    retriever = SynapseRetriever(synapse=syn, k=5)
+    docs = retriever.invoke("Who created Python?")
+    assert len(docs) > 0
+    assert all(isinstance(d, Document) for d in docs)
+
+
+def test_empty_retrieval():
+    syn = Synapse(":memory:")
+    retriever = SynapseRetriever(synapse=syn, k=5)
+    docs = retriever.invoke("anything")
+    assert docs == []