antonlytics 2.1.0__tar.gz → 2.3.0__tar.gz

{antonlytics-2.1.0 → antonlytics-2.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: antonlytics
-Version: 2.1.0
+Version: 2.3.0
 Summary: Memory for AI Agents - Simple natural language SDK
 Home-page: https://github.com/Voidback-Inc/antonlytics-python-sdk
 Author: Voidback

antonlytics-2.3.0/antonlytics/__init__.py

@@ -0,0 +1,22 @@
+"""
+Antonlytics Python SDK — Memory + Ontology infrastructure for AI agents
+and SaaS applications.
+
+Two entry points:
+
+  * ``Agent``        — project-scoped: ingest, chat, retrieval, system prompt.
+  * ``Antonlytics``  — account-level: project CRUD, plus ``.agent()`` factory.
+"""
+
+from .agent import Agent
+from .client import Antonlytics
+from .exceptions import AntonlyticsError, APIError, AuthenticationError
+
+__version__ = "2.3.0"  # bumped: ingest_triplets + Antonlytics client
+__all__ = [
+    "Agent",
+    "Antonlytics",
+    "AntonlyticsError",
+    "APIError",
+    "AuthenticationError",
+]

{antonlytics-2.1.0 → antonlytics-2.3.0}/antonlytics/agent.py

@@ -2,7 +2,7 @@
 Agent class for interacting with Antonlytics API.
 """
 
-from typing import Dict, Any, Optional, List
+from typing import Dict, Any, Optional, List, Iterator
 from .http_client import HTTPClient
 from .exceptions import AntonlyticsError
 
@@ -51,6 +51,70 @@ class Agent:
         self.base_url = base_url.rstrip('/')
         self.client = HTTPClient(api_key, base_url)
     
+    def ingest_triplets(self, triplets: List[Dict[str, Any]]) -> Dict[str, Any]:
+        """
+        Ingest pre-formed triplets directly — bypasses Claude extraction.
+
+        Use this from SaaS applications when your code already knows the
+        structured data (rows from a DB, parsed events, etc.) and you don't
+        want to pay LLM extraction cost / latency.
+
+        Each triplet is:
+            {
+              "subject":   {"type": str, "id": str, "properties": dict},
+              "predicate": str,   # e.g. "PURCHASED"
+              "object":    {"type": str, "id": str, "properties": dict},
+              "relationship_properties": dict (optional)
+            }
+
+        Args:
+            triplets: list of triplet dicts.
+
+        Returns:
+            ``{"success": bool, "event_id": str, "async": bool, "results": {...}}``
+            Batches over 100 are processed asynchronously; poll
+            ``Agent.ingestion_event_status(event_id)``.
+        """
+        if not triplets:
+            raise AntonlyticsError("triplets must be a non-empty list")
+        return self.client.post('/api/v1/ingest/', {
+            'project_id': self.project_id,
+            'triplets': triplets,
+        })
+
+    def upsert_entity(
+        self,
+        type: str,
+        external_id: str,
+        properties: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        """Convenience: create or update a single entity (no relationship).
+
+        Internally posts a self-referential triplet which the engine treats as
+        an entity upsert — same code path as direct ingestion."""
+        return self.ingest_triplets([{
+            'subject':   {'type': type, 'id': external_id, 'properties': properties or {}},
+            'predicate': 'SELF',
+            'object':    {'type': type, 'id': external_id, 'properties': properties or {}},
+        }])
+
+    def add_relationship(
+        self,
+        source: Dict[str, Any],
+        predicate: str,
+        target: Dict[str, Any],
+        relationship_properties: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        """Convenience: post a single (source --[predicate]--> target) edge.
+
+        Both endpoints are upserted if they don't already exist."""
+        return self.ingest_triplets([{
+            'subject':                  source,
+            'predicate':                predicate,
+            'object':                   target,
+            'relationship_properties':  relationship_properties or {},
+        }])
+
     def ingest(self, text: str) -> Dict[str, Any]:
         """
         Ingest text and extract entities/relationships.
@@ -121,41 +185,89 @@ class Agent:
             
         return self.client.post('/api/v1/memory/chat/', payload)
     
-    def get_memory(self, query: Optional[str] = None) -> Dict[str, Any]:
+    def get_memory(
+        self,
+        query: Optional[str] = None,
+        *,
+        max_entities: int = 10_000,
+        page_size: int = 500,
+    ) -> Dict[str, Any]:
         """
         Get memory context for your own agent/model.
-        Returns structured knowledge graph data.
-        
+
+        Two modes:
+          - ``query`` provided: semantic top-K retrieval (single shot, server-ranked).
+            Returns the most relevant entities and their relationships.
+          - ``query=None``: enumerates the full project graph via cursor pagination,
+            auto-iterating pages internally. Stops at ``max_entities`` for safety.
+
         Args:
-            query: Optional natural language query to filter context
-            
+            query: Optional natural language query for ranked retrieval.
+            max_entities: Safety ceiling for full-graph mode (default 10000).
+            page_size: Pagination page size for full-graph mode (1-1000, default 500).
+
         Returns:
-            Dict with entities and relationships
-            
+            Dict with entities and relationships.
+
         Example:
-            >>> # Get all memory
-            >>> memory = agent.get_memory()
-            >>> 
-            >>> # Use with your own model
-            >>> your_model.chat(
-            ...     system="You are a sales assistant",
-            ...     context=memory,
-            ...     message="Who to follow up?"
-            ... )
+            >>> # Top-K retrieval for prompt context
+            >>> memory = agent.get_memory(query="What did Sarah say?")
+            >>>
+            >>> # Full project dump (auto-paginated)
+            >>> all_memory = agent.get_memory()
+            >>>
+            >>> # For very large projects, stream pages:
+            >>> for page in agent.iter_memory(page_size=500):
+            ...     process(page)
         """
         if query:
             response = self.client.post('/api/v1/memory/query/', {
                 'question': query,
-                'project_id': self.project_id
-            })
-            return response.get('graph_context', {})
-        else:
-            # Get all memory
-            response = self.client.post('/api/v1/memory/query/', {
-                'question': 'What do you know?',
-                'project_id': self.project_id
+                'project_id': self.project_id,
             })
             return response.get('graph_context', {})
+
+        # Full-graph mode: auto-paginate via /memory/list/.
+        entities: List[Dict[str, Any]] = []
+        relationships: List[Dict[str, Any]] = []
+        for page in self.iter_memory(page_size=page_size):
+            entities.extend(page.get('entities', []))
+            relationships.extend(page.get('relationships', []))
+            if len(entities) >= max_entities:
+                entities = entities[:max_entities]
+                break
+        return {'entities': entities, 'relationships': relationships}
+
+    def iter_memory(self, page_size: int = 500) -> Iterator[Dict[str, Any]]:
+        """
+        Stream the full project graph one page at a time.
+
+        Yields a dict ``{entities, relationships, next_cursor, has_more}`` per page.
+        Iteration stops automatically when the server reports no more pages.
+
+        Args:
+            page_size: Rows per page (1-1000, default 500).
+
+        Example:
+            >>> for page in agent.iter_memory(page_size=200):
+            ...     for entity in page["entities"]:
+            ...         print(entity["name"])
+        """
+        cursor: Optional[str] = None
+        while True:
+            payload: Dict[str, Any] = {
+                'project_id': self.project_id,
+                'limit': page_size,
+            }
+            if cursor:
+                payload['cursor'] = cursor
+            page = self.client.post('/api/v1/memory/list/', payload)
+            yield page
+            if not page.get('has_more'):
+                break
+            cursor = page.get('next_cursor')
+            if not cursor:
+                break
     
     def set_system_prompt(self, prompt: str) -> Dict[str, Any]:
         """

antonlytics-2.3.0/antonlytics/client.py

@@ -0,0 +1,70 @@
+"""
+Account-level client. For SaaS apps that manage many projects with one API key.
+
+    from antonlytics import Antonlytics
+
+    client = Antonlytics(api_key="...")
+
+    # Create a project on the API key's team
+    project = client.create_project(name="customer_42", scope="Customer 42 dataset")
+
+    # Per-project work — same Agent surface as before
+    agent = client.agent(project_id=project["id"])
+    agent.ingest_triplets([...])
+
+The Agent class is unchanged — Antonlytics is just a thin factory + project
+management wrapper that reuses the same HTTPClient.
+"""
+from typing import Dict, Any, List, Optional
+
+from .http_client import HTTPClient
+from .agent import Agent
+from .exceptions import AntonlyticsError
+
+
+class Antonlytics:
+    """Account-level entry point. Use this for project CRUD; use ``.agent()``
+    to get a project-scoped Agent for ingestion / chat / retrieval."""
+
+    def __init__(self, api_key: str, base_url: str = "https://api.antonlytics.com"):
+        if not api_key:
+            raise AntonlyticsError("API key is required")
+        self.api_key = api_key
+        self.base_url = base_url.rstrip("/")
+        self.client = HTTPClient(api_key, self.base_url)
+
+    # ── Project CRUD ─────────────────────────────────────────────────────
+
+    def list_projects(self) -> List[Dict[str, Any]]:
+        """Return all projects this API key has access to."""
+        r = self.client.get("/api/v1/graph/projects/")
+        return r.get("results", r) if isinstance(r, dict) else r
+
+    def create_project(self, name: str, scope: Optional[str] = None,
+                       description: Optional[str] = None) -> Dict[str, Any]:
+        """Create a new project on the team this API key belongs to."""
+        if not name or not name.strip():
+            raise AntonlyticsError("Project name is required")
+        payload: Dict[str, Any] = {"name": name.strip()}
+        if scope:        payload["scope"] = scope
+        if description:  payload["description"] = description
+        return self.client.post("/api/v1/graph/projects/", payload)
+
+    def get_project(self, project_id: str) -> Dict[str, Any]:
+        return self.client.get(f"/api/v1/graph/projects/{project_id}/")
+
+    def delete_project(self, project_id: str) -> Dict[str, Any]:
+        return self.client.delete(f"/api/v1/graph/projects/{project_id}/")
+
+    def project_stats(self, project_id: str) -> Dict[str, Any]:
+        return self.client.get(f"/api/v1/graph/projects/{project_id}/stats/")
+
+    def project_ontology(self, project_id: str) -> Dict[str, Any]:
+        return self.client.get(f"/api/v1/graph/projects/{project_id}/ontology/")
+
+    # ── Agent factory ────────────────────────────────────────────────────
+
+    def agent(self, project_id: str) -> Agent:
+        """Return an Agent scoped to ``project_id``. Reuses this client's
+        API key + base URL — no extra config needed."""
+        return Agent(api_key=self.api_key, project_id=project_id, base_url=self.base_url)

{antonlytics-2.1.0 → antonlytics-2.3.0}/antonlytics.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: antonlytics
-Version: 2.1.0
+Version: 2.3.0
 Summary: Memory for AI Agents - Simple natural language SDK
 Home-page: https://github.com/Voidback-Inc/antonlytics-python-sdk
 Author: Voidback

{antonlytics-2.1.0 → antonlytics-2.3.0}/antonlytics.egg-info/SOURCES.txt

@@ -8,6 +8,7 @@ setup.py
 .pyre/pyre.stderr
 antonlytics/__init__.py
 antonlytics/agent.py
+antonlytics/client.py
 antonlytics/exceptions.py
 antonlytics/http_client.py
 antonlytics.egg-info/PKG-INFO

{antonlytics-2.1.0 → antonlytics-2.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "antonlytics"
-version = "2.1.0"
+version = "2.3.0"
 description = "Memory for AI Agents - Simple natural language SDK"
 readme = "README.md"
 requires-python = ">=3.8"

{antonlytics-2.1.0 → antonlytics-2.3.0}/setup.py

@@ -9,7 +9,7 @@ with open("README.md", "r", encoding="utf-8") as fh:
 
 setup(
     name="antonlytics",
-    version="2.1.0",
+    version="2.3.0",
     author="Voidback",
     author_email="hello@voidback.com",
     description="Memory for AI Agents - Simple natural language SDK",

antonlytics-2.1.0/antonlytics/__init__.py

@@ -1,11 +0,0 @@
-"""
-Antonlytics Python SDK - Memory for AI Agents
-
-Simple SDK for giving your AI agent persistent memory.
-"""
-
-from .agent import Agent
-from .exceptions import AntonlyticsError, APIError, AuthenticationError
-
-__version__ = "2.1.0"
-__all__ = ["Agent", "AntonlyticsError", "APIError", "AuthenticationError"]