memcell 0.1.1__tar.gz

memcell-0.1.1/.gitignore

@@ -0,0 +1,34 @@
+# Dependencies
+node_modules/
+.pnpm-store/
+
+# Build artifacts
+dist/
+build/
+*.egg-info/
+.eggs/
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+.venv/
+env/
+venv/
+.mypy_cache/
+.pytest_cache/
+.ruff_cache/
+.coverage
+htmlcov/
+
+# Logs & Environment
+*.log
+.env
+.env.*
+!.env.example
+
+# OS & Editors
+.DS_Store
+.vscode/
+.idea/
+*.swp

memcell-0.1.1/CHANGELOG.md

@@ -0,0 +1,8 @@
+# Changelog
+
+## [0.1.1](https://github.com/memcell-ai/sdk/compare/python-v0.1.0...python-v0.1.1) (2026-09-17)
+
+
+### Features
+
+* initialize multi-language sdk monorepo for typescript and python ([d5da445](https://github.com/memcell-ai/sdk/commit/d5da4457c5f6f3f87287f41f21acb921592f0d0a))

memcell-0.1.1/PKG-INFO

@@ -0,0 +1,112 @@
+Metadata-Version: 2.5
+Name: memcell
+Version: 0.1.1
+Summary: Official Python SDK for MemCell persistent cognitive memory and reasoning engine
+Author-email: MemCell Team <engineering@memcell.io>
+License-Expression: Apache-2.0
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software 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
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: pydantic>=2.0.0
+Provides-Extra: dev
+Requires-Dist: pytest-asyncio>=0.23.0; extra == 'dev'
+Requires-Dist: pytest>=8.0.0; extra == 'dev'
+Requires-Dist: respx>=0.21.0; extra == 'dev'
+Requires-Dist: ruff>=0.3.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# memcell
+
+Official Python SDK for [MemCell](https://memcell.io)—persistent cognitive memory and reasoning substrate for AI coding agents.
+
+## Installation
+
+```bash
+pip install memcell
+# or
+uv add memcell
+# or
+poetry add memcell
+```
+
+## Quickstart
+
+### Asynchronous Client (`AsyncMemCell`)
+
+```python
+import asyncio
+from memcell import AsyncMemCell
+
+async def main():
+    async with AsyncMemCell(api_key="mc_live_...") as memory:
+        # Pre-flight recall before an agent acts
+        recall = await memory.recall(
+            namespace="acme/devops",
+            query="how to deploy the canary pipeline"
+        )
+        print(recall.prompt_context)
+
+        # In-flight scoped execution with automatic reinforcement
+        devops = memory.scope("acme/devops", subject="pipeline:canary")
+        result = await devops.wrap_execution(
+            action="deploy_canary",
+            external_ref="ci:run:1049",
+            fn=lambda ctx: print("Deploying with context:", ctx.prompt_context)
+        )
+
+asyncio.run(main())
+```
+
+### Synchronous Client (`MemCell`)
+
+```python
+from memcell import MemCell
+
+memory = MemCell(api_key="mc_live_...")
+
+recall = memory.recall(
+    namespace="acme/backend",
+    query="database connection pool configuration"
+)
+for statement in recall.statements:
+    print(f"[{statement.kind}] {statement.title} (confidence: {statement.confidence})")
+```
+
+### OAuth 2.0 Machine-to-Machine (M2M)
+
+```python
+from memcell import AsyncMemCell
+
+memory = AsyncMemCell(
+    client_id="client_xyz",
+    client_secret="secret_xyz",
+    scope="memory:read:acme/* memory:write:acme/backend"
+)
+# Automatically handles token exchange and proactively refreshes before expiration!
+```
+
+### Rate Limiting & Resilience
+
+```python
+from memcell import AsyncMemCell
+
+memory = AsyncMemCell(
+    api_key="mc_live_...",
+    max_retries=3,
+    on_rate_limit_warning=lambda warning, response: print(f"Warning: {warning}")
+)
+# Automatically performs jittered exponential backoff respecting server Retry-After!
+```
+
+## License
+
+Apache-2.0 © [MemCell](https://memcell.io)

memcell-0.1.1/README.md

@@ -0,0 +1,86 @@
+# memcell
+
+Official Python SDK for [MemCell](https://memcell.io)—persistent cognitive memory and reasoning substrate for AI coding agents.
+
+## Installation
+
+```bash
+pip install memcell
+# or
+uv add memcell
+# or
+poetry add memcell
+```
+
+## Quickstart
+
+### Asynchronous Client (`AsyncMemCell`)
+
+```python
+import asyncio
+from memcell import AsyncMemCell
+
+async def main():
+    async with AsyncMemCell(api_key="mc_live_...") as memory:
+        # Pre-flight recall before an agent acts
+        recall = await memory.recall(
+            namespace="acme/devops",
+            query="how to deploy the canary pipeline"
+        )
+        print(recall.prompt_context)
+
+        # In-flight scoped execution with automatic reinforcement
+        devops = memory.scope("acme/devops", subject="pipeline:canary")
+        result = await devops.wrap_execution(
+            action="deploy_canary",
+            external_ref="ci:run:1049",
+            fn=lambda ctx: print("Deploying with context:", ctx.prompt_context)
+        )
+
+asyncio.run(main())
+```
+
+### Synchronous Client (`MemCell`)
+
+```python
+from memcell import MemCell
+
+memory = MemCell(api_key="mc_live_...")
+
+recall = memory.recall(
+    namespace="acme/backend",
+    query="database connection pool configuration"
+)
+for statement in recall.statements:
+    print(f"[{statement.kind}] {statement.title} (confidence: {statement.confidence})")
+```
+
+### OAuth 2.0 Machine-to-Machine (M2M)
+
+```python
+from memcell import AsyncMemCell
+
+memory = AsyncMemCell(
+    client_id="client_xyz",
+    client_secret="secret_xyz",
+    scope="memory:read:acme/* memory:write:acme/backend"
+)
+# Automatically handles token exchange and proactively refreshes before expiration!
+```
+
+### Rate Limiting & Resilience
+
+```python
+from memcell import AsyncMemCell
+
+memory = AsyncMemCell(
+    api_key="mc_live_...",
+    max_retries=3,
+    on_rate_limit_warning=lambda warning, response: print(f"Warning: {warning}")
+)
+# Automatically performs jittered exponential backoff respecting server Retry-After!
+```
+
+## License
+
+Apache-2.0 © [MemCell](https://memcell.io)

memcell-0.1.1/pyproject.toml

@@ -0,0 +1,65 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "memcell"
+version = "0.1.1"
+description = "Official Python SDK for MemCell persistent cognitive memory and reasoning engine"
+readme = "README.md"
+license = "Apache-2.0"
+requires-python = ">=3.10"
+authors = [
+    { name = "MemCell Team", email = "engineering@memcell.io" }
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: Apache Software 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 :: Software Development :: Libraries :: Python Modules",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+dependencies = [
+    "httpx>=0.27.0",
+    "pydantic>=2.0.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0.0",
+    "pytest-asyncio>=0.23.0",
+    "respx>=0.21.0",
+    "ruff>=0.3.0",
+]
+
+[tool.ruff]
+line-length = 100
+target-version = "py310"
+include = ["src/**/*.py", "tests/**/*.py"]
+
+[tool.ruff.lint]
+select = [
+    "E",
+    "F",
+    "W",
+    "I",
+    "UP",
+    "RUF",
+]
+ignore = [
+    "E501",
+]
+
+[tool.ruff.lint.per-file-ignores]
+"tests/*" = ["S101"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+testpaths = ["tests"]
+pythonpath = ["src"]
+

memcell-0.1.1/src/memcell/__init__.py

@@ -0,0 +1,45 @@
+from .auth import AuthManager
+from .client import AsyncMemCell, MemCell
+from .exceptions import MemCellError, RateLimitError
+from .models import (
+    FeedbackResponse,
+    JobEvent,
+    MemoryKind,
+    MemoryStatus,
+    OrganizationItem,
+    OutcomeVerdict,
+    RecallResponse,
+    RememberResponse,
+    ReportResponse,
+    ScopedExecutionContext,
+    StatementItem,
+)
+from .organization import AsyncOrganizationMemCell, OrganizationMemCell
+from .scoped import AsyncScopedMemCell, ScopedExecutionResult, ScopedMemCell
+
+__version__ = "0.1.1"
+
+__all__ = [
+    "AsyncMemCell",
+    "AsyncOrganizationMemCell",
+    "AsyncScopedMemCell",
+    "AuthManager",
+    "FeedbackResponse",
+    "JobEvent",
+    "MemCell",
+    "MemCellError",
+    "MemoryKind",
+    "MemoryStatus",
+    "OrganizationItem",
+    "OrganizationMemCell",
+    "OutcomeVerdict",
+    "RateLimitError",
+    "RecallResponse",
+    "RememberResponse",
+    "ReportResponse",
+    "ScopedExecutionContext",
+    "ScopedExecutionResult",
+    "ScopedMemCell",
+    "StatementItem",
+    "__version__",
+]

memcell-0.1.1/src/memcell/auth.py

@@ -0,0 +1,137 @@
+import time
+from typing import Any
+
+import httpx
+
+from .exceptions import MemCellError
+
+
+class AuthManager:
+    """Manages authentication tokens, API keys, and OAuth 2.0 M2M client credentials."""
+
+    def __init__(
+        self,
+        base_url: str,
+        api_key: str | None = None,
+        access_token: str | None = None,
+        client_id: str | None = None,
+        client_secret: str | None = None,
+        scope: str | None = None,
+    ) -> None:
+        self.base_url = base_url.rstrip("/")
+        self.api_key = api_key
+        self.access_token = access_token
+        self.client_id = client_id
+        self.client_secret = client_secret
+        self.scope = scope
+
+        self._cached_token: str | None = None
+        self._token_expires_at: float = 0.0
+
+    def clear_cache(self) -> None:
+        """Clears cached OAuth M2M access token."""
+        self._cached_token = None
+        self._token_expires_at = 0.0
+
+    def get_authorization_header(self, client: httpx.Client | None = None) -> str | None:
+        """Synchronously resolves Authorization header value."""
+        if self.api_key:
+            return f"Bearer {self.api_key}"
+        if self.access_token:
+            return f"Bearer {self.access_token}"
+        if self.client_id and self.client_secret:
+            # Check proactive 60s pre-expiry window
+            now = time.time()
+            if self._cached_token and (now + 60.0) < self._token_expires_at:
+                return f"Bearer {self._cached_token}"
+
+            c = client or httpx.Client()
+            should_close = client is None
+            try:
+                data = {
+                    "grant_type": "client_credentials",
+                    "client_id": self.client_id,
+                    "client_secret": self.client_secret,
+                }
+                if self.scope:
+                    data["scope"] = self.scope
+
+                resp = c.post(
+                    f"{self.base_url}/oauth2/token",
+                    data=data,
+                    headers={
+                        "Content-Type": "application/x-www-form-urlencoded",
+                        "Accept": "application/json",
+                    },
+                )
+                if not resp.is_success:
+                    raise MemCellError(
+                        f"OAuth M2M token exchange failed: HTTP {resp.status_code} {resp.text}",
+                        status=resp.status_code,
+                    )
+                payload: dict[str, Any] = resp.json()
+                token = payload.get("access_token")
+                expires_in = payload.get("expires_in", 3600)
+                if not token:
+                    raise MemCellError("OAuth token endpoint returned empty access_token.")
+
+                self._cached_token = str(token)
+                self._token_expires_at = time.time() + float(expires_in)
+                return f"Bearer {self._cached_token}"
+            finally:
+                if should_close:
+                    c.close()
+
+        return None
+
+    async def get_authorization_header_async(
+        self, client: httpx.AsyncClient | None = None
+    ) -> str | None:
+        """Asynchronously resolves Authorization header value."""
+        if self.api_key:
+            return f"Bearer {self.api_key}"
+        if self.access_token:
+            return f"Bearer {self.access_token}"
+        if self.client_id and self.client_secret:
+            now = time.time()
+            if self._cached_token and (now + 60.0) < self._token_expires_at:
+                return f"Bearer {self._cached_token}"
+
+            c = client or httpx.AsyncClient()
+            should_close = client is None
+            try:
+                data = {
+                    "grant_type": "client_credentials",
+                    "client_id": self.client_id,
+                    "client_secret": self.client_secret,
+                }
+                if self.scope:
+                    data["scope"] = self.scope
+
+                resp = await c.post(
+                    f"{self.base_url}/oauth2/token",
+                    data=data,
+                    headers={
+                        "Content-Type": "application/x-www-form-urlencoded",
+                        "Accept": "application/json",
+                    },
+                )
+                if not resp.is_success:
+                    raise MemCellError(
+                        f"OAuth M2M token exchange failed: HTTP {resp.status_code} {resp.text}",
+                        status=resp.status_code,
+                    )
+                payload: dict[str, Any] = resp.json()
+                token = payload.get("access_token")
+                expires_in = payload.get("expires_in", 3600)
+                if not token:
+                    raise MemCellError("OAuth token endpoint returned empty access_token.")
+
+                self._cached_token = str(token)
+                self._token_expires_at = time.time() + float(expires_in)
+                return f"Bearer {self._cached_token}"
+            finally:
+                if should_close:
+                    await c.aclose()
+
+        return None