mcal-ai-langgraph 0.2.0__tar.gz

mcal_ai_langgraph-0.2.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Shiva
+
+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.

mcal_ai_langgraph-0.2.0/PKG-INFO

@@ -0,0 +1,147 @@
+Metadata-Version: 2.4
+Name: mcal-ai-langgraph
+Version: 0.2.0
+Summary: LangGraph integration for MCAL - Goal-aware memory for AI agents
+Author: MCAL Team
+License: MIT
+Project-URL: Homepage, https://github.com/Shivakoreddi/mcal-ai
+Project-URL: Documentation, https://github.com/Shivakoreddi/mcal-ai/blob/main/docs/integrations/langgraph.md
+Project-URL: Repository, https://github.com/Shivakoreddi/mcal-ai.git
+Project-URL: Issues, https://github.com/Shivakoreddi/mcal-ai/issues
+Keywords: mcal,langgraph,memory,agents,llm,goal-aware,langchain
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: mcal-ai>=0.1.0
+Requires-Dist: langgraph>=0.0.40
+Requires-Dist: langchain-core>=0.1.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.4.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Dynamic: license-file
+
+# mcal-langgraph
+
+LangGraph integration for [MCAL](https://github.com/Shivakoreddi/mcla-research) - Goal-aware memory for AI agents.
+
+## Installation
+
+```bash
+pip install mcal-langgraph
+```
+
+This will automatically install `mcal` and `langgraph` as dependencies.
+
+## Quick Start
+
+```python
+from mcal import MCAL
+from mcal_langgraph import MCALStore
+
+# Initialize MCAL with a goal
+mcal = MCAL(goal="Build a fraud detection system")
+
+# Create LangGraph-compatible store
+store = MCALStore(mcal)
+
+# Use with LangGraph
+from langgraph.prebuilt import create_react_agent
+
+agent = create_react_agent(
+    model=your_model,
+    tools=your_tools,
+    store=store  # Goal-aware memory!
+)
+```
+
+## Features
+
+### MCALStore (BaseStore)
+
+Drop-in replacement for LangGraph's built-in stores with **goal-aware** memory:
+
+```python
+from mcal_langgraph import MCALStore
+
+store = MCALStore(mcal)
+
+# Store memories
+await store.aput(
+    namespace=("user_123", "memories"),
+    key="decision_1",
+    value={"text": "Decided to use PostgreSQL for ACID compliance"}
+)
+
+# Goal-aware search - returns memories relevant to current goals
+results = await store.asearch(
+    namespace_prefix=("user_123",),
+    query="database choice"
+)
+
+# Results include goal context and decisions
+for item in results:
+    print(item.value["goals"])      # Related goals
+    print(item.value["decisions"])  # Related decisions
+```
+
+### MCALMemory
+
+Memory nodes for custom LangGraph workflows:
+
+```python
+from mcal_langgraph import MCALMemory
+
+memory = MCALMemory(llm_provider="anthropic")
+
+# Add as nodes in your graph
+graph.add_node("update_memory", memory.update_node())
+graph.add_node("get_context", memory.context_node())
+```
+
+### MCALCheckpointer
+
+State persistence for LangGraph graphs:
+
+```python
+from mcal_langgraph import MCALCheckpointer
+
+checkpointer = MCALCheckpointer(mcal)
+graph = builder.compile(checkpointer=checkpointer)
+```
+
+## Why mcal-langgraph?
+
+| Feature | LangGraph InMemoryStore | **MCALStore** |
+|---------|------------------------|---------------|
+| BaseStore interface | ✅ | ✅ |
+| Namespace organization | ✅ | ✅ |
+| **Goal-aware search** | ❌ | ✅ |
+| **Decision tracking** | ❌ | ✅ |
+| **Intent preservation** | ❌ | ✅ |
+
+## Migrating from mcal[langgraph]
+
+If you were using the old extras-based installation:
+
+```python
+# Old way (deprecated)
+from mcal.integrations.langgraph import MCALStore
+
+# New way (recommended)
+from mcal_langgraph import MCALStore
+```
+
+The old import path still works but will show a deprecation warning.
+
+## License
+
+MIT

mcal_ai_langgraph-0.2.0/README.md

@@ -0,0 +1,116 @@
+# mcal-langgraph
+
+LangGraph integration for [MCAL](https://github.com/Shivakoreddi/mcla-research) - Goal-aware memory for AI agents.
+
+## Installation
+
+```bash
+pip install mcal-langgraph
+```
+
+This will automatically install `mcal` and `langgraph` as dependencies.
+
+## Quick Start
+
+```python
+from mcal import MCAL
+from mcal_langgraph import MCALStore
+
+# Initialize MCAL with a goal
+mcal = MCAL(goal="Build a fraud detection system")
+
+# Create LangGraph-compatible store
+store = MCALStore(mcal)
+
+# Use with LangGraph
+from langgraph.prebuilt import create_react_agent
+
+agent = create_react_agent(
+    model=your_model,
+    tools=your_tools,
+    store=store  # Goal-aware memory!
+)
+```
+
+## Features
+
+### MCALStore (BaseStore)
+
+Drop-in replacement for LangGraph's built-in stores with **goal-aware** memory:
+
+```python
+from mcal_langgraph import MCALStore
+
+store = MCALStore(mcal)
+
+# Store memories
+await store.aput(
+    namespace=("user_123", "memories"),
+    key="decision_1",
+    value={"text": "Decided to use PostgreSQL for ACID compliance"}
+)
+
+# Goal-aware search - returns memories relevant to current goals
+results = await store.asearch(
+    namespace_prefix=("user_123",),
+    query="database choice"
+)
+
+# Results include goal context and decisions
+for item in results:
+    print(item.value["goals"])      # Related goals
+    print(item.value["decisions"])  # Related decisions
+```
+
+### MCALMemory
+
+Memory nodes for custom LangGraph workflows:
+
+```python
+from mcal_langgraph import MCALMemory
+
+memory = MCALMemory(llm_provider="anthropic")
+
+# Add as nodes in your graph
+graph.add_node("update_memory", memory.update_node())
+graph.add_node("get_context", memory.context_node())
+```
+
+### MCALCheckpointer
+
+State persistence for LangGraph graphs:
+
+```python
+from mcal_langgraph import MCALCheckpointer
+
+checkpointer = MCALCheckpointer(mcal)
+graph = builder.compile(checkpointer=checkpointer)
+```
+
+## Why mcal-langgraph?
+
+| Feature | LangGraph InMemoryStore | **MCALStore** |
+|---------|------------------------|---------------|
+| BaseStore interface | ✅ | ✅ |
+| Namespace organization | ✅ | ✅ |
+| **Goal-aware search** | ❌ | ✅ |
+| **Decision tracking** | ❌ | ✅ |
+| **Intent preservation** | ❌ | ✅ |
+
+## Migrating from mcal[langgraph]
+
+If you were using the old extras-based installation:
+
+```python
+# Old way (deprecated)
+from mcal.integrations.langgraph import MCALStore
+
+# New way (recommended)
+from mcal_langgraph import MCALStore
+```
+
+The old import path still works but will show a deprecation warning.
+
+## License
+
+MIT

mcal_ai_langgraph-0.2.0/pyproject.toml

@@ -0,0 +1,50 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "mcal-ai-langgraph"
+version = "0.2.0"
+description = "LangGraph integration for MCAL - Goal-aware memory for AI agents"
+readme = "README.md"
+license = {text = "MIT"}
+authors = [
+    {name = "MCAL Team"}
+]
+requires-python = ">=3.11"
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+keywords = ["mcal", "langgraph", "memory", "agents", "llm", "goal-aware", "langchain"]
+
+dependencies = [
+    "mcal-ai>=0.1.0",
+    "langgraph>=0.0.40",
+    "langchain-core>=0.1.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.4.0",
+    "pytest-asyncio>=0.21.0",
+    "pytest-cov>=4.0.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/Shivakoreddi/mcal-ai"
+Documentation = "https://github.com/Shivakoreddi/mcal-ai/blob/main/docs/integrations/langgraph.md"
+Repository = "https://github.com/Shivakoreddi/mcal-ai.git"
+Issues = "https://github.com/Shivakoreddi/mcal-ai/issues"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+mcal_langgraph = ["py.typed"]

mcal_ai_langgraph-0.2.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

mcal_ai_langgraph-0.2.0/src/mcal_ai_langgraph.egg-info/PKG-INFO

@@ -0,0 +1,147 @@
+Metadata-Version: 2.4
+Name: mcal-ai-langgraph
+Version: 0.2.0
+Summary: LangGraph integration for MCAL - Goal-aware memory for AI agents
+Author: MCAL Team
+License: MIT
+Project-URL: Homepage, https://github.com/Shivakoreddi/mcal-ai
+Project-URL: Documentation, https://github.com/Shivakoreddi/mcal-ai/blob/main/docs/integrations/langgraph.md
+Project-URL: Repository, https://github.com/Shivakoreddi/mcal-ai.git
+Project-URL: Issues, https://github.com/Shivakoreddi/mcal-ai/issues
+Keywords: mcal,langgraph,memory,agents,llm,goal-aware,langchain
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: mcal-ai>=0.1.0
+Requires-Dist: langgraph>=0.0.40
+Requires-Dist: langchain-core>=0.1.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.4.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Dynamic: license-file
+
+# mcal-langgraph
+
+LangGraph integration for [MCAL](https://github.com/Shivakoreddi/mcla-research) - Goal-aware memory for AI agents.
+
+## Installation
+
+```bash
+pip install mcal-langgraph
+```
+
+This will automatically install `mcal` and `langgraph` as dependencies.
+
+## Quick Start
+
+```python
+from mcal import MCAL
+from mcal_langgraph import MCALStore
+
+# Initialize MCAL with a goal
+mcal = MCAL(goal="Build a fraud detection system")
+
+# Create LangGraph-compatible store
+store = MCALStore(mcal)
+
+# Use with LangGraph
+from langgraph.prebuilt import create_react_agent
+
+agent = create_react_agent(
+    model=your_model,
+    tools=your_tools,
+    store=store  # Goal-aware memory!
+)
+```
+
+## Features
+
+### MCALStore (BaseStore)
+
+Drop-in replacement for LangGraph's built-in stores with **goal-aware** memory:
+
+```python
+from mcal_langgraph import MCALStore
+
+store = MCALStore(mcal)
+
+# Store memories
+await store.aput(
+    namespace=("user_123", "memories"),
+    key="decision_1",
+    value={"text": "Decided to use PostgreSQL for ACID compliance"}
+)
+
+# Goal-aware search - returns memories relevant to current goals
+results = await store.asearch(
+    namespace_prefix=("user_123",),
+    query="database choice"
+)
+
+# Results include goal context and decisions
+for item in results:
+    print(item.value["goals"])      # Related goals
+    print(item.value["decisions"])  # Related decisions
+```
+
+### MCALMemory
+
+Memory nodes for custom LangGraph workflows:
+
+```python
+from mcal_langgraph import MCALMemory
+
+memory = MCALMemory(llm_provider="anthropic")
+
+# Add as nodes in your graph
+graph.add_node("update_memory", memory.update_node())
+graph.add_node("get_context", memory.context_node())
+```
+
+### MCALCheckpointer
+
+State persistence for LangGraph graphs:
+
+```python
+from mcal_langgraph import MCALCheckpointer
+
+checkpointer = MCALCheckpointer(mcal)
+graph = builder.compile(checkpointer=checkpointer)
+```
+
+## Why mcal-langgraph?
+
+| Feature | LangGraph InMemoryStore | **MCALStore** |
+|---------|------------------------|---------------|
+| BaseStore interface | ✅ | ✅ |
+| Namespace organization | ✅ | ✅ |
+| **Goal-aware search** | ❌ | ✅ |
+| **Decision tracking** | ❌ | ✅ |
+| **Intent preservation** | ❌ | ✅ |
+
+## Migrating from mcal[langgraph]
+
+If you were using the old extras-based installation:
+
+```python
+# Old way (deprecated)
+from mcal.integrations.langgraph import MCALStore
+
+# New way (recommended)
+from mcal_langgraph import MCALStore
+```
+
+The old import path still works but will show a deprecation warning.
+
+## License
+
+MIT

mcal_ai_langgraph-0.2.0/src/mcal_ai_langgraph.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+LICENSE
+README.md
+pyproject.toml
+src/mcal_ai_langgraph.egg-info/PKG-INFO
+src/mcal_ai_langgraph.egg-info/SOURCES.txt
+src/mcal_ai_langgraph.egg-info/dependency_links.txt
+src/mcal_ai_langgraph.egg-info/requires.txt
+src/mcal_ai_langgraph.egg-info/top_level.txt
+src/mcal_langgraph/__init__.py
+src/mcal_langgraph/_compat.py
+src/mcal_langgraph/checkpointer.py
+src/mcal_langgraph/memory.py
+src/mcal_langgraph/py.typed
+src/mcal_langgraph/store.py
+tests/test_integration.py
+tests/test_store.py

mcal_ai_langgraph-0.2.0/src/mcal_ai_langgraph.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

mcal_ai_langgraph-0.2.0/src/mcal_ai_langgraph.egg-info/requires.txt

@@ -0,0 +1,8 @@
+mcal-ai>=0.1.0
+langgraph>=0.0.40
+langchain-core>=0.1.0
+
+[dev]
+pytest>=7.4.0
+pytest-asyncio>=0.21.0
+pytest-cov>=4.0.0

mcal_ai_langgraph-0.2.0/src/mcal_ai_langgraph.egg-info/top_level.txt

@@ -0,0 +1 @@
+mcal_langgraph

mcal_ai_langgraph-0.2.0/src/mcal_langgraph/__init__.py

@@ -0,0 +1,39 @@
+"""
+mcal-langgraph: LangGraph integration for MCAL
+
+Provides goal-aware memory for LangGraph agent workflows:
+- MCALStore: BaseStore implementation with goal-aware search
+- MCALMemory: Memory nodes for LangGraph workflows  
+- MCALCheckpointer: State persistence for graphs
+
+Installation:
+    pip install mcal-langgraph
+
+Usage:
+    from mcal import MCAL
+    from mcal_langgraph import MCALStore
+    
+    mcal = MCAL(goal="Build fraud detection system")
+    store = MCALStore(mcal)
+    
+    # Use with LangGraph
+    from langgraph.prebuilt import create_react_agent
+    agent = create_react_agent(model, tools, store=store)
+"""
+
+from mcal_langgraph.store import MCALStore
+from mcal_langgraph.memory import MCALMemory, MCALMemoryConfig
+from mcal_langgraph.checkpointer import MCALCheckpointer
+from mcal_langgraph._compat import LANGGRAPH_AVAILABLE
+
+# Version
+__version__ = "0.1.0"
+
+__all__ = [
+    "MCALStore",
+    "MCALMemory",
+    "MCALMemoryConfig",
+    "MCALCheckpointer",
+    "LANGGRAPH_AVAILABLE",
+    "__version__",
+]

mcal_ai_langgraph-0.2.0/src/mcal_langgraph/_compat.py

@@ -0,0 +1,71 @@
+"""
+Compatibility layer for LangGraph imports.
+
+Handles graceful degradation when langgraph is not installed.
+"""
+
+from __future__ import annotations
+from typing import Any
+
+# Check for LangGraph availability
+try:
+    from langgraph.graph import StateGraph
+    from langgraph.checkpoint.base import BaseCheckpointSaver
+    from langgraph.store.base import (
+        BaseStore,
+        Item,
+        SearchItem,
+        GetOp,
+        PutOp,
+        SearchOp,
+        ListNamespacesOp,
+        NamespacePath,
+    )
+    from langchain_core.messages import BaseMessage, HumanMessage, AIMessage
+    
+    LANGGRAPH_AVAILABLE = True
+except ImportError:
+    LANGGRAPH_AVAILABLE = False
+    StateGraph = None
+    BaseCheckpointSaver = object
+    BaseStore = object
+    Item = None
+    SearchItem = None
+    GetOp = None
+    PutOp = None
+    SearchOp = None
+    ListNamespacesOp = None
+    NamespacePath = None
+    BaseMessage = Any
+    HumanMessage = Any
+    AIMessage = Any
+
+
+def check_langgraph():
+    """Raise helpful error if LangGraph not installed."""
+    if not LANGGRAPH_AVAILABLE:
+        raise ImportError(
+            "mcal-langgraph requires langgraph package.\n"
+            "Install with: pip install mcal-langgraph\n"
+            "Or manually: pip install langgraph langchain-core"
+        )
+
+
+# Export everything needed by other modules
+__all__ = [
+    "LANGGRAPH_AVAILABLE",
+    "check_langgraph",
+    "StateGraph",
+    "BaseCheckpointSaver",
+    "BaseStore",
+    "Item",
+    "SearchItem",
+    "GetOp",
+    "PutOp",
+    "SearchOp",
+    "ListNamespacesOp",
+    "NamespacePath",
+    "BaseMessage",
+    "HumanMessage",
+    "AIMessage",
+]

mcal_ai_langgraph-0.2.0/src/mcal_langgraph/checkpointer.py

@@ -0,0 +1,53 @@
+"""
+MCALCheckpointer: State persistence for LangGraph graphs.
+
+Stores graph state alongside MCAL memory for unified persistence.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional
+
+from mcal_langgraph._compat import (
+    check_langgraph,
+    LANGGRAPH_AVAILABLE,
+    BaseCheckpointSaver,
+)
+
+
+class MCALCheckpointer(BaseCheckpointSaver if LANGGRAPH_AVAILABLE else object):
+    """
+    MCAL-based checkpointer for LangGraph state persistence.
+    
+    Stores graph state alongside MCAL memory for unified persistence.
+    
+    Usage:
+        from mcal_langgraph import MCALCheckpointer
+        
+        checkpointer = MCALCheckpointer(storage_path="~/.mcal")
+        graph = StateGraph(...).compile(checkpointer=checkpointer)
+    """
+    
+    def __init__(self, storage_path: Optional[str] = None):
+        check_langgraph()
+        if LANGGRAPH_AVAILABLE:
+            super().__init__()
+        self.storage_path = storage_path
+        self._checkpoints: Dict[str, Any] = {}
+    
+    def get(self, config: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+        """Get checkpoint by config."""
+        thread_id = config.get("configurable", {}).get("thread_id", "default")
+        return self._checkpoints.get(thread_id)
+    
+    def put(self, config: Dict[str, Any], checkpoint: Dict[str, Any]) -> None:
+        """Save checkpoint."""
+        thread_id = config.get("configurable", {}).get("thread_id", "default")
+        self._checkpoints[thread_id] = checkpoint
+    
+    def list(self, config: Dict[str, Any]) -> List[Dict[str, Any]]:
+        """List all checkpoints."""
+        return list(self._checkpoints.values())
+
+
+__all__ = ["MCALCheckpointer"]