zerolatency 0.1.0__tar.gz

zerolatency-0.1.0/.gitignore

@@ -0,0 +1,5 @@
+__pycache__/
+*.egg-info/
+dist/
+build/
+*.pyc

zerolatency-0.1.0/LICENSE

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

zerolatency-0.1.0/PKG-INFO

@@ -0,0 +1,126 @@
+Metadata-Version: 2.4
+Name: zerolatency
+Version: 0.1.0
+Summary: Python SDK for the 0Latency memory API — persistent memory for AI agents.
+Project-URL: Homepage, https://0latency.ai
+Project-URL: Documentation, https://docs.0latency.ai
+Project-URL: Repository, https://github.com/0latency/zerolatency-python
+Author-email: 0Latency <dev@0latency.ai>
+License: MIT
+License-File: LICENSE
+Keywords: agents,ai,llm,memory,rag
+Classifier: Development Status :: 3 - Alpha
+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
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.24
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == 'dev'
+Requires-Dist: respx>=0.20; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# zerolatency
+
+Python SDK for the [0Latency](https://0latency.ai) memory API — persistent memory for AI agents.
+
+## Install
+
+```bash
+pip install zerolatency
+```
+
+## Quick start
+
+```python
+from zerolatency import Memory
+
+memory = Memory("your-api-key")
+
+# Store a memory
+memory.add("User said they prefer dark mode and work in Python")
+
+# Recall relevant memories
+context = memory.recall("What are the user's preferences?")
+print(context)
+```
+
+## Usage
+
+### Store memories
+
+```python
+memory.add(
+    "User prefers concise answers",
+    agent_id="agent-123",
+    metadata={"source": "onboarding"},
+)
+```
+
+### Recall memories
+
+```python
+results = memory.recall("communication style", agent_id="agent-123", limit=5)
+for m in results["memories"]:
+    print(m["content"])
+```
+
+### Extract memories from a conversation
+
+```python
+conversation = [
+    {"role": "user", "content": "I'm a backend engineer who uses FastAPI."},
+    {"role": "assistant", "content": "Great! I'll keep that in mind."},
+]
+
+job = memory.extract(conversation, agent_id="agent-123")
+status = memory.extract_status(job["job_id"])
+```
+
+### Health check
+
+```python
+print(memory.health())
+```
+
+### Context manager
+
+```python
+with Memory("your-api-key") as memory:
+    memory.add("something to remember")
+```
+
+## Error handling
+
+```python
+from zerolatency import Memory, AuthenticationError, RateLimitError, ZeroLatencyError
+
+try:
+    memory = Memory("bad-key")
+    memory.add("test")
+except AuthenticationError:
+    print("Check your API key")
+except RateLimitError:
+    print("Slow down — retry after a backoff")
+except ZeroLatencyError as e:
+    print(f"API error {e.status_code}: {e.message}")
+```
+
+## Configuration
+
+| Parameter  | Default                      | Description              |
+|------------|------------------------------|--------------------------|
+| `api_key`  | *required*                   | Your 0Latency API key    |
+| `base_url` | `https://api.0latency.ai`   | API base URL override    |
+| `timeout`  | `30.0`                       | Request timeout (seconds)|
+
+## License
+
+MIT

zerolatency-0.1.0/README.md

@@ -0,0 +1,97 @@
+# zerolatency
+
+Python SDK for the [0Latency](https://0latency.ai) memory API — persistent memory for AI agents.
+
+## Install
+
+```bash
+pip install zerolatency
+```
+
+## Quick start
+
+```python
+from zerolatency import Memory
+
+memory = Memory("your-api-key")
+
+# Store a memory
+memory.add("User said they prefer dark mode and work in Python")
+
+# Recall relevant memories
+context = memory.recall("What are the user's preferences?")
+print(context)
+```
+
+## Usage
+
+### Store memories
+
+```python
+memory.add(
+    "User prefers concise answers",
+    agent_id="agent-123",
+    metadata={"source": "onboarding"},
+)
+```
+
+### Recall memories
+
+```python
+results = memory.recall("communication style", agent_id="agent-123", limit=5)
+for m in results["memories"]:
+    print(m["content"])
+```
+
+### Extract memories from a conversation
+
+```python
+conversation = [
+    {"role": "user", "content": "I'm a backend engineer who uses FastAPI."},
+    {"role": "assistant", "content": "Great! I'll keep that in mind."},
+]
+
+job = memory.extract(conversation, agent_id="agent-123")
+status = memory.extract_status(job["job_id"])
+```
+
+### Health check
+
+```python
+print(memory.health())
+```
+
+### Context manager
+
+```python
+with Memory("your-api-key") as memory:
+    memory.add("something to remember")
+```
+
+## Error handling
+
+```python
+from zerolatency import Memory, AuthenticationError, RateLimitError, ZeroLatencyError
+
+try:
+    memory = Memory("bad-key")
+    memory.add("test")
+except AuthenticationError:
+    print("Check your API key")
+except RateLimitError:
+    print("Slow down — retry after a backoff")
+except ZeroLatencyError as e:
+    print(f"API error {e.status_code}: {e.message}")
+```
+
+## Configuration
+
+| Parameter  | Default                      | Description              |
+|------------|------------------------------|--------------------------|
+| `api_key`  | *required*                   | Your 0Latency API key    |
+| `base_url` | `https://api.0latency.ai`   | API base URL override    |
+| `timeout`  | `30.0`                       | Request timeout (seconds)|
+
+## License
+
+MIT

zerolatency-0.1.0/pyproject.toml

@@ -0,0 +1,40 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "zerolatency"
+version = "0.1.0"
+description = "Python SDK for the 0Latency memory API — persistent memory for AI agents."
+readme = "README.md"
+license = {text = "MIT"}
+requires-python = ">=3.10"
+authors = [{ name = "0Latency", email = "dev@0latency.ai" }]
+keywords = ["ai", "memory", "agents", "llm", "rag"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "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",
+    "Typing :: Typed",
+]
+dependencies = ["httpx>=0.24"]
+
+[project.urls]
+Homepage = "https://0latency.ai"
+Documentation = "https://docs.0latency.ai"
+Repository = "https://github.com/0latency/zerolatency-python"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/zerolatency"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+[project.optional-dependencies]
+dev = ["pytest>=7", "respx>=0.20", "ruff"]

zerolatency-0.1.0/src/zerolatency/__init__.py

@@ -0,0 +1,13 @@
+"""0Latency — Memory layer for AI agents."""
+
+from .client import Memory
+from .errors import AuthenticationError, RateLimitError, ZeroLatencyError
+
+__all__ = [
+    "Memory",
+    "ZeroLatencyError",
+    "AuthenticationError",
+    "RateLimitError",
+]
+
+__version__ = "0.1.0"

zerolatency-0.1.0/src/zerolatency/client.py

@@ -0,0 +1,165 @@
+"""0Latency Memory client."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+
+from .errors import AuthenticationError, RateLimitError, ZeroLatencyError
+
+DEFAULT_BASE_URL = "https://api.0latency.ai"
+DEFAULT_TIMEOUT = 30.0
+
+
+class Memory:
+    """Client for the 0Latency memory API.
+
+    Usage::
+
+        from zerolatency import Memory
+
+        memory = Memory("your-api-key")
+        memory.add("User prefers dark mode")
+        results = memory.recall("What does the user prefer?")
+    """
+
+    def __init__(
+        self,
+        api_key: str,
+        base_url: str | None = None,
+        timeout: float = DEFAULT_TIMEOUT,
+    ) -> None:
+        self.api_key = api_key
+        self.base_url = (base_url or DEFAULT_BASE_URL).rstrip("/")
+        self._client = httpx.Client(
+            base_url=self.base_url,
+            headers={
+                "Authorization": f"Bearer {api_key}",
+                "Content-Type": "application/json",
+                "User-Agent": "zerolatency-python/0.1.0",
+            },
+            timeout=timeout,
+        )
+
+    # -- public API ----------------------------------------------------------
+
+    def add(
+        self,
+        content: str,
+        agent_id: str | None = None,
+        metadata: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        """Store a memory.
+
+        Args:
+            content: The text content to remember.
+            agent_id: Optional agent identifier for scoping memories.
+            metadata: Optional key-value metadata to attach.
+
+        Returns:
+            API confirmation payload.
+        """
+        payload: dict[str, Any] = {"content": content}
+        if agent_id is not None:
+            payload["agent_id"] = agent_id
+        if metadata is not None:
+            payload["metadata"] = metadata
+        return self._post("/v1/memories", payload)
+
+    def recall(
+        self,
+        query: str,
+        agent_id: str | None = None,
+        limit: int = 10,
+    ) -> dict[str, Any]:
+        """Retrieve relevant memories.
+
+        Args:
+            query: Natural-language search query.
+            agent_id: Optional agent identifier for scoping.
+            limit: Maximum number of results (default 10).
+
+        Returns:
+            Matching memories from the API.
+        """
+        params: dict[str, Any] = {"query": query, "limit": limit}
+        if agent_id is not None:
+            params["agent_id"] = agent_id
+        return self._get("/v1/memories/recall", params)
+
+    def extract(
+        self,
+        conversation: list[dict[str, str]],
+        agent_id: str | None = None,
+    ) -> dict[str, Any]:
+        """Start async memory extraction from a conversation.
+
+        Args:
+            conversation: List of message dicts (e.g. ``[{"role": "user", "content": "..."}]``).
+            agent_id: Optional agent identifier.
+
+        Returns:
+            Dict containing ``job_id`` for status polling.
+        """
+        payload: dict[str, Any] = {"conversation": conversation}
+        if agent_id is not None:
+            payload["agent_id"] = agent_id
+        return self._post("/v1/memories/extract", payload)
+
+    def extract_status(self, job_id: str) -> dict[str, Any]:
+        """Check the status of an extraction job.
+
+        Args:
+            job_id: The job identifier returned by :meth:`extract`.
+
+        Returns:
+            Job status payload.
+        """
+        return self._get(f"/v1/memories/extract/{job_id}")
+
+    def health(self) -> dict[str, Any]:
+        """Check API health.
+
+        Returns:
+            Health status payload.
+        """
+        return self._get("/v1/health")
+
+    # -- lifecycle -----------------------------------------------------------
+
+    def close(self) -> None:
+        """Close the underlying HTTP connection."""
+        self._client.close()
+
+    def __enter__(self) -> Memory:
+        return self
+
+    def __exit__(self, *exc: object) -> None:
+        self.close()
+
+    # -- internals -----------------------------------------------------------
+
+    def _post(self, path: str, json: dict[str, Any]) -> dict[str, Any]:
+        return self._handle(self._client.post(path, json=json))
+
+    def _get(self, path: str, params: dict[str, Any] | None = None) -> dict[str, Any]:
+        return self._handle(self._client.get(path, params=params))
+
+    @staticmethod
+    def _handle(response: httpx.Response) -> dict[str, Any]:
+        if response.is_success:
+            return response.json()  # type: ignore[no-any-return]
+
+        try:
+            body = response.json()
+        except Exception:
+            body = None
+
+        if response.status_code == 401:
+            raise AuthenticationError(response=body)
+        if response.status_code == 429:
+            raise RateLimitError(response=body)
+
+        msg = body.get("detail", response.text) if isinstance(body, dict) else response.text
+        raise ZeroLatencyError(msg, status_code=response.status_code, response=body)

zerolatency-0.1.0/src/zerolatency/errors.py

@@ -0,0 +1,25 @@
+"""Exception classes for the 0Latency SDK."""
+
+
+class ZeroLatencyError(Exception):
+    """Base exception for all 0Latency API errors."""
+
+    def __init__(self, message: str, status_code: int | None = None, response: dict | None = None) -> None:
+        self.message = message
+        self.status_code = status_code
+        self.response = response
+        super().__init__(self.message)
+
+
+class AuthenticationError(ZeroLatencyError):
+    """Raised when the API key is invalid or missing."""
+
+    def __init__(self, message: str = "Invalid or missing API key.", response: dict | None = None) -> None:
+        super().__init__(message, status_code=401, response=response)
+
+
+class RateLimitError(ZeroLatencyError):
+    """Raised when the API rate limit is exceeded."""
+
+    def __init__(self, message: str = "Rate limit exceeded. Please retry later.", response: dict | None = None) -> None:
+        super().__init__(message, status_code=429, response=response)

zerolatency-0.1.0/tests/test_client.py

@@ -0,0 +1,154 @@
+"""Tests for the zerolatency SDK client."""
+
+import httpx
+import pytest
+import respx
+
+from zerolatency import AuthenticationError, Memory, RateLimitError, ZeroLatencyError
+
+BASE = "https://api.0latency.ai"
+
+
+@pytest.fixture()
+def memory():
+    client = Memory("test-key")
+    yield client
+    client.close()
+
+
+# -- add ---------------------------------------------------------------------
+
+
+@respx.mock
+def test_add_basic(memory: Memory):
+    route = respx.post(f"{BASE}/v1/memories").mock(
+        return_value=httpx.Response(200, json={"id": "mem_1", "status": "ok"})
+    )
+    result = memory.add("remember this")
+    assert result == {"id": "mem_1", "status": "ok"}
+    assert route.called
+    payload = route.calls.last.request.content
+    assert b"remember this" in payload
+
+
+@respx.mock
+def test_add_with_agent_and_metadata(memory: Memory):
+    respx.post(f"{BASE}/v1/memories").mock(
+        return_value=httpx.Response(200, json={"id": "mem_2"})
+    )
+    result = memory.add("fact", agent_id="a1", metadata={"src": "test"})
+    assert result["id"] == "mem_2"
+
+
+# -- recall ------------------------------------------------------------------
+
+
+@respx.mock
+def test_recall(memory: Memory):
+    respx.get(f"{BASE}/v1/memories/recall").mock(
+        return_value=httpx.Response(200, json={"memories": [{"content": "dark mode"}]})
+    )
+    result = memory.recall("preferences")
+    assert len(result["memories"]) == 1
+
+
+@respx.mock
+def test_recall_with_params(memory: Memory):
+    route = respx.get(f"{BASE}/v1/memories/recall").mock(
+        return_value=httpx.Response(200, json={"memories": []})
+    )
+    memory.recall("q", agent_id="a1", limit=5)
+    url = str(route.calls.last.request.url)
+    assert "agent_id=a1" in url
+    assert "limit=5" in url
+
+
+# -- extract -----------------------------------------------------------------
+
+
+@respx.mock
+def test_extract(memory: Memory):
+    respx.post(f"{BASE}/v1/memories/extract").mock(
+        return_value=httpx.Response(200, json={"job_id": "job_1"})
+    )
+    result = memory.extract([{"role": "user", "content": "hi"}])
+    assert result["job_id"] == "job_1"
+
+
+@respx.mock
+def test_extract_status(memory: Memory):
+    respx.get(f"{BASE}/v1/memories/extract/job_1").mock(
+        return_value=httpx.Response(200, json={"status": "completed"})
+    )
+    result = memory.extract_status("job_1")
+    assert result["status"] == "completed"
+
+
+# -- health ------------------------------------------------------------------
+
+
+@respx.mock
+def test_health(memory: Memory):
+    respx.get(f"{BASE}/v1/health").mock(
+        return_value=httpx.Response(200, json={"status": "healthy"})
+    )
+    assert memory.health()["status"] == "healthy"
+
+
+# -- errors ------------------------------------------------------------------
+
+
+@respx.mock
+def test_auth_error(memory: Memory):
+    respx.post(f"{BASE}/v1/memories").mock(
+        return_value=httpx.Response(401, json={"detail": "unauthorized"})
+    )
+    with pytest.raises(AuthenticationError) as exc_info:
+        memory.add("test")
+    assert exc_info.value.status_code == 401
+
+
+@respx.mock
+def test_rate_limit_error(memory: Memory):
+    respx.post(f"{BASE}/v1/memories").mock(
+        return_value=httpx.Response(429, json={"detail": "too many requests"})
+    )
+    with pytest.raises(RateLimitError) as exc_info:
+        memory.add("test")
+    assert exc_info.value.status_code == 429
+
+
+@respx.mock
+def test_generic_error(memory: Memory):
+    respx.post(f"{BASE}/v1/memories").mock(
+        return_value=httpx.Response(500, json={"detail": "internal error"})
+    )
+    with pytest.raises(ZeroLatencyError) as exc_info:
+        memory.add("test")
+    assert exc_info.value.status_code == 500
+    assert "internal error" in exc_info.value.message
+
+
+# -- context manager ---------------------------------------------------------
+
+
+@respx.mock
+def test_context_manager():
+    respx.get(f"{BASE}/v1/health").mock(
+        return_value=httpx.Response(200, json={"status": "healthy"})
+    )
+    with Memory("test-key") as mem:
+        assert mem.health()["status"] == "healthy"
+
+
+# -- headers -----------------------------------------------------------------
+
+
+@respx.mock
+def test_auth_header(memory: Memory):
+    route = respx.get(f"{BASE}/v1/health").mock(
+        return_value=httpx.Response(200, json={})
+    )
+    memory.health()
+    auth = route.calls.last.request.headers["authorization"]
+    assert auth == "Bearer test-key"