synapse-layer 2.3.0__tar.gz → 2.3.1__tar.gz

{synapse_layer-2.3.0 → synapse_layer-2.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: synapse-layer
-Version: 2.3.0
+Version: 2.3.1
 Summary: Universal memory layer for AI agents - Persistent, Private, Model-agnostic
 Author-email: Synapse Layer <founder.synapselayer@proton.me>
 Project-URL: Homepage, https://synapselayer.org

{synapse_layer-2.3.0 → synapse_layer-2.3.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "synapse-layer"
-version = "2.3.0"
+version = "2.3.1"
 authors = [
   { name="Synapse Layer", email="founder.synapselayer@proton.me" },
 ]

synapse_layer-2.3.1/synapse_layer/__init__.py

@@ -0,0 +1,70 @@
+"""
+Synapse Layer — Universal memory layer for AI agents.
+Persistent, Private, Model-agnostic.
+
+MCP-native. LangChain-compatible. A2A-ready.
+
+Core (always available):
+    from synapse_layer import SynapseA2AClient
+
+LangChain adapter (requires langchain-core):
+    from synapse_layer import SynapseMemory, SynapseChatHistory
+
+CrewAI tools (requires crewai):
+    from synapse_layer import SynapseStoreMemoryTool, SynapseRecallMemoryTool
+"""
+
+__version__ = "2.3.1"
+
+# Core — always importable, zero optional deps
+from .a2a_client import SynapseA2AClient
+
+
+# ---------------------------------------------------------------------------
+# Lazy accessors for optional integrations
+# ---------------------------------------------------------------------------
+
+def __getattr__(name: str):
+    """Lazy-load optional adapters only when accessed."""
+
+    # LangChain adapters
+    if name in ("SynapseMemory", "SynapseChatHistory"):
+        try:
+            from . import langchain_memory as _lc  # noqa: F811
+        except ImportError as exc:
+            raise ImportError(
+                f"{name} requires langchain-core. "
+                "Install with: pip install 'synapse-layer[langchain]'"
+            ) from exc
+        return getattr(_lc, name)
+
+    # CrewAI tools
+    if name in (
+        "SynapseStoreMemoryTool",
+        "SynapseRecallMemoryTool",
+        "SynapseHandoverTool",
+    ):
+        try:
+            from . import crewai_tools as _ct  # noqa: F811
+        except ImportError as exc:
+            raise ImportError(
+                f"{name} requires crewai. "
+                "Install with: pip install 'synapse-layer[crewai]'"
+            ) from exc
+        return getattr(_ct, name)
+
+    raise AttributeError(f"module 'synapse_layer' has no attribute {name!r}")
+
+
+__all__ = [
+    "__version__",
+    # Core
+    "SynapseA2AClient",
+    # LangChain (lazy)
+    "SynapseMemory",
+    "SynapseChatHistory",
+    # CrewAI (lazy)
+    "SynapseStoreMemoryTool",
+    "SynapseRecallMemoryTool",
+    "SynapseHandoverTool",
+]

{synapse_layer-2.3.0 → synapse_layer-2.3.1}/synapse_layer/crewai_tools.py

@@ -8,6 +8,8 @@ Provides three CrewAI tools for Agent-to-Agent memory management:
 
 TQ Formula: TQ = (confidence_score * 0.4) + (recency_score * 0.3) + (usage_normalized * 0.3)
 
+Requires: pip install 'synapse-layer[crewai]'
+
 Author: Ismael Marchi
 License: Apache 2.0
 """
@@ -20,8 +22,15 @@ from pydantic import BaseModel, Field
 
 try:
     from crewai.tools import BaseTool
+    _CREWAI_AVAILABLE = True
 except ImportError:
-    raise ImportError("crewai is required for CrewAI tools. Install with: pip install 'synapse-layer[crewai]'")
+    _CREWAI_AVAILABLE = False
+
+if not _CREWAI_AVAILABLE:
+    raise ImportError(
+        "crewai is required for CrewAI tools. "
+        "Install with: pip install 'synapse-layer[crewai]'"
+    )
 
 from .a2a_client import SynapseA2AClient, TaskResult
 
@@ -123,10 +132,8 @@ class _SynapseBaseTool(BaseTool):
             loop = None
 
         if loop is None:
-            # No running loop, create new event loop
             return asyncio.run(coro)
         else:
-            # Running loop exists, use ThreadPoolExecutor
             with ThreadPoolExecutor(max_workers=1) as executor:
                 future = executor.submit(asyncio.run, coro)
                 return future.result()
@@ -166,18 +173,6 @@ class SynapseStoreMemoryTool(_SynapseBaseTool):
         source_type: str = "api_response",
         confidence: float = 0.8,
     ) -> str:
-        """
-        Synchronous wrapper for storing memory.
-
-        Args:
-            user_id: User UUID
-            content: Memory content
-            source_type: Memory source (default: api_response)
-            confidence: Confidence score 0.0-1.0 (default: 0.8)
-
-        Returns:
-            JSON string with TaskResult
-        """
         coro = self._async_run(user_id, content, source_type, confidence)
         result = self._run_sync(coro)
         return str(result)
@@ -189,18 +184,6 @@ class SynapseStoreMemoryTool(_SynapseBaseTool):
         source_type: str = "api_response",
         confidence: float = 0.8,
     ) -> TaskResult:
-        """
-        Asynchronous implementation of store_memory.
-
-        Args:
-            user_id: User UUID
-            content: Memory content
-            source_type: Memory source
-            confidence: Confidence score
-
-        Returns:
-            TaskResult
-        """
         async with SynapseA2AClient(api_key=self.api_key, base_url=self.base_url) as client:
             return await client.store_memory(
                 user_id=user_id,
@@ -216,18 +199,6 @@ class SynapseStoreMemoryTool(_SynapseBaseTool):
         source_type: str = "api_response",
         confidence: float = 0.8,
     ) -> str:
-        """
-        Async run method for CrewAI compatibility.
-
-        Args:
-            user_id: User UUID
-            content: Memory content
-            source_type: Memory source
-            confidence: Confidence score
-
-        Returns:
-            JSON string with TaskResult
-        """
         result = await self._async_run(user_id, content, source_type, confidence)
         return str(result)
 
@@ -243,13 +214,6 @@ class SynapseRecallMemoryTool(_SynapseBaseTool):
 
     Retrieves memories ordered by Trust Quotient (TQ) score.
     TQ = (confidence_score * 0.4) + (recency_score * 0.3) + (usage_normalized * 0.3)
-
-    Args:
-        api_key: Synapse Layer API key
-        base_url: API endpoint (default: Supabase Edge Function)
-
-    Returns:
-        TaskResult with list of retrieved memories
     """
 
     name: str = "synapse_recall_memory"
@@ -265,17 +229,6 @@ class SynapseRecallMemoryTool(_SynapseBaseTool):
         query: str,
         limit: int = 10,
     ) -> str:
-        """
-        Synchronous wrapper for recalling memory.
-
-        Args:
-            user_id: User UUID
-            query: Semantic search query
-            limit: Max memories to retrieve (default: 10)
-
-        Returns:
-            JSON string with TaskResult
-        """
         coro = self._async_run(user_id, query, limit)
         result = self._run_sync(coro)
         return str(result)
@@ -286,17 +239,6 @@ class SynapseRecallMemoryTool(_SynapseBaseTool):
         query: str,
         limit: int = 10,
     ) -> TaskResult:
-        """
-        Asynchronous implementation of recall_memory.
-
-        Args:
-            user_id: User UUID
-            query: Semantic search query
-            limit: Max memories to retrieve
-
-        Returns:
-            TaskResult
-        """
         async with SynapseA2AClient(api_key=self.api_key, base_url=self.base_url) as client:
             return await client.recall_memory(
                 user_id=user_id,
@@ -310,17 +252,6 @@ class SynapseRecallMemoryTool(_SynapseBaseTool):
         query: str,
         limit: int = 10,
     ) -> str:
-        """
-        Async run method for CrewAI compatibility.
-
-        Args:
-            user_id: User UUID
-            query: Semantic search query
-            limit: Max memories to retrieve
-
-        Returns:
-            JSON string with TaskResult
-        """
         result = await self._async_run(user_id, query, limit)
         return str(result)
 
@@ -335,14 +266,6 @@ class SynapseHandoverTool(_SynapseBaseTool):
     Tool for creating Neural Handover context to target model.
 
     Packages agent context with HMAC-SHA256 signature for secure transfer.
-    Supports handover to different AI models (Claude, GPT, etc.).
-
-    Args:
-        api_key: Synapse Layer API key
-        base_url: API endpoint (default: Supabase Edge Function)
-
-    Returns:
-        TaskResult with handover context and signature
     """
 
     name: str = "synapse_create_handover"
@@ -358,17 +281,6 @@ class SynapseHandoverTool(_SynapseBaseTool):
         target_model: str,
         summary: str,
     ) -> str:
-        """
-        Synchronous wrapper for creating handover.
-
-        Args:
-            user_id: User UUID
-            target_model: Target model ID
-            summary: Context summary
-
-        Returns:
-            JSON string with TaskResult
-        """
         coro = self._async_run(user_id, target_model, summary)
         result = self._run_sync(coro)
         return str(result)
@@ -379,17 +291,6 @@ class SynapseHandoverTool(_SynapseBaseTool):
         target_model: str,
         summary: str,
     ) -> TaskResult:
-        """
-        Asynchronous implementation of create_handover.
-
-        Args:
-            user_id: User UUID
-            target_model: Target model ID
-            summary: Context summary
-
-        Returns:
-            TaskResult
-        """
         async with SynapseA2AClient(api_key=self.api_key, base_url=self.base_url) as client:
             return await client.create_handover(
                 user_id=user_id,
@@ -403,17 +304,6 @@ class SynapseHandoverTool(_SynapseBaseTool):
         target_model: str,
         summary: str,
     ) -> str:
-        """
-        Async run method for CrewAI compatibility.
-
-        Args:
-            user_id: User UUID
-            target_model: Target model ID
-            summary: Context summary
-
-        Returns:
-            JSON string with TaskResult
-        """
         result = await self._async_run(user_id, target_model, summary)
         return str(result)
 

{synapse_layer-2.3.0 → synapse_layer-2.3.1}/synapse_layer/langchain_memory.py

@@ -9,6 +9,8 @@ Implements Trust Quotient (TQ) formula for memory evaluation:
 Two adapters provided:
 1. SynapseChatHistory — BaseChatMessageHistory for persistent chat histories
 2. SynapseMemory — BaseMemory for general agent memory management
+
+Requires: pip install 'synapse-layer[langchain]'
 """
 
 import asyncio
@@ -20,10 +22,15 @@ try:
     from langchain_core.messages import BaseMessage, HumanMessage, AIMessage, SystemMessage
     from langchain_core.memory import BaseMemory
     from pydantic import Field, validator
-except ImportError as e:
+    _LANGCHAIN_AVAILABLE = True
+except ImportError:
+    _LANGCHAIN_AVAILABLE = False
+
+if not _LANGCHAIN_AVAILABLE:
     raise ImportError(
-        "langchain-core is required. Install: pip install langchain-core"
-    ) from e
+        "langchain-core is required for LangChain adapters. "
+        "Install with: pip install 'synapse-layer[langchain]'"
+    )
 
 from .a2a_client import SynapseA2AClient, TaskResult, TaskState
 
@@ -31,12 +38,12 @@ from .a2a_client import SynapseA2AClient, TaskResult, TaskState
 class SynapseChatHistory(BaseChatMessageHistory):
     """
     Chat message history backed by Synapse Layer persistent memory.
-    
+
     Uses store_memory to persist each message and recall_memory to load
     conversation context. Applies TQ formula for smart recall:
-    
+
         TQ = (confidence * 0.4) + (recency * 0.3) + (usage * 0.3)
-    
+
     Example:
         history = SynapseChatHistory(
             api_key="synapse-key",
@@ -64,17 +71,17 @@ class SynapseChatHistory(BaseChatMessageHistory):
     async def add_message(self, message: BaseMessage) -> None:
         """
         Add message to history and persist via Synapse Layer.
-        
+
         Automatically determines source_type from message class:
         - HumanMessage -> "user_input"
         - AIMessage -> "inference"
         - SystemMessage -> "system"
-        
+
         Args:
             message: LangChain BaseMessage instance
         """
         self._messages.append(message)
-        
+
         # Determine source type
         if isinstance(message, HumanMessage):
             source_type = "user_input"
@@ -91,7 +98,7 @@ class SynapseChatHistory(BaseChatMessageHistory):
     async def _persist(self, content: str, source_type: str) -> None:
         """
         Persist message content to Synapse Layer.
-        
+
         Args:
             content: Message text to store
             source_type: Origin type (user_input, inference, system)
@@ -117,18 +124,18 @@ class SynapseChatHistory(BaseChatMessageHistory):
 class SynapseMemory(BaseMemory):
     """
     General agent memory backed by Synapse Layer persistent storage.
-    
+
     Implements BaseMemory interface for LangChain agents. Applies Trust Quotient
     formula to all recall operations:
-    
+
         TQ = (confidence * 0.4) + (recency * 0.3) + (usage * 0.3)
-    
+
     Supports:
     - Persistent memory across sessions
     - Semantic search via pgvector HNSW
-    - Multi-model context sharing via Neural Handover
+    - Multi-model context sharing
     - Automatic conflict resolution via Consensus Engine
-    
+
     Example:
         memory = SynapseMemory(
             api_key="synapse-key",
@@ -167,13 +174,13 @@ class SynapseMemory(BaseMemory):
     async def load_memory_variables(self, inputs: Dict[str, Any]) -> Dict[str, Any]:
         """
         Load relevant memories based on input query.
-        
+
         Uses recall_memory with TQ weighting to find relevant context:
             TQ = (confidence * 0.4) + (recency * 0.3) + (usage * 0.3)
-        
+
         Args:
             inputs: Dict with at least input_key containing the query
-            
+
         Returns:
             Dict with memory_key -> formatted memory text
         """
@@ -187,12 +194,12 @@ class SynapseMemory(BaseMemory):
     async def _recall(self, query: str) -> str:
         """
         Recall memories matching query.
-        
+
         Applies Trust Quotient formula and formats results.
-        
+
         Args:
             query: Natural language query
-            
+
         Returns:
             Formatted memory context string
         """
@@ -226,22 +233,20 @@ class SynapseMemory(BaseMemory):
     def save_context(self, inputs: Dict[str, Any], outputs: Dict[str, str]) -> None:
         """
         Save input/output pair to memory (sync wrapper).
-        
+
         For async operation, use _store directly.
-        
+
         Args:
             inputs: Agent inputs dict
             outputs: Agent outputs dict
         """
-        # For sync context, we can't await. Use asyncio.run if in main thread.
         input_text = inputs.get(self.input_key, "")
         output_text = outputs.get("output", "")
-        
+
         if input_text:
             try:
                 asyncio.run(self._store(input_text, "user_input"))
             except RuntimeError:
-                # Already in event loop, schedule as task
                 pass
 
         if output_text:
@@ -253,7 +258,7 @@ class SynapseMemory(BaseMemory):
     async def _store(self, content: str, source_type: str) -> None:
         """
         Store content to Synapse memory.
-        
+
         Args:
             content: Text to store
             source_type: Origin type (user_input, inference, system)
@@ -274,7 +279,7 @@ class SynapseMemory(BaseMemory):
     def clear(self) -> None:
         """
         Clear operation not supported for persistent Synapse memory.
-        
+
         Memories are designed to persist across sessions. To remove specific
         memories, use SynapseA2AClient.forget_memory() directly.
         """

{synapse_layer-2.3.0 → synapse_layer-2.3.1}/synapse_layer.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: synapse-layer
-Version: 2.3.0
+Version: 2.3.1
 Summary: Universal memory layer for AI agents - Persistent, Private, Model-agnostic
 Author-email: Synapse Layer <founder.synapselayer@proton.me>
 Project-URL: Homepage, https://synapselayer.org

synapse_layer-2.3.0/synapse_layer/__init__.py

@@ -1,13 +0,0 @@
-"""
-Synapse Layer — Universal memory layer for AI agents.
-Persistent, Private, Model-agnostic.
-
-MCP-native. LangChain-compatible. A2A-ready.
-"""
-
-__version__ = "2.3.0"
-
-from .a2a_client import SynapseA2AClient
-from .langchain_memory import SynapseMemory
-
-__all__ = ["SynapseA2AClient", "SynapseMemory", "__version__"]