rotalabs-context 1.0.0__py3-none-any.whl

rotalabs_context/__init__.py

@@ -0,0 +1,36 @@
+"""
+rotalabs-context: Context intelligence for AI agents.
+
+Provides tools to ingest, search, and subscribe to shared context
+across AI systems. Works standalone (local mode) or connected to
+the Rotascale platform (managed mode).
+
+Usage:
+    from rotalabs_context import ContextEngine
+
+    ctx = ContextEngine()
+    ctx.ingest(records=[{"content": "hello"}], source="test")
+    results = ctx.search("hello")
+"""
+
+from rotalabs_context._version import __version__
+from rotalabs_context.engine import ContextEngine
+from rotalabs_context.models import (
+    ContextEntry,
+    IngestResult,
+    SearchHit,
+    SearchResult,
+    Scope,
+    Sensitivity,
+)
+
+__all__ = [
+    "__version__",
+    "ContextEngine",
+    "ContextEntry",
+    "IngestResult",
+    "SearchHit",
+    "SearchResult",
+    "Scope",
+    "Sensitivity",
+]

rotalabs_context/_telemetry.py

@@ -0,0 +1,34 @@
+"""Telemetry integration for rotalabs-context.
+
+Safe wrapper around the rotalabs telemetry system.
+Opt-in only, gracefully degrades if not configured.
+"""
+
+from typing import Any
+
+try:
+    from rotalabs._telemetry import is_enabled, report_event
+except ImportError:
+    def report_event(*args: Any, **kwargs: Any) -> None:
+        pass
+
+    def is_enabled() -> bool:
+        return False
+
+
+def report_context_init(backend: str) -> None:
+    if not is_enabled():
+        return
+    report_event("context.engine.init", {"backend": backend})
+
+
+def report_context_ingest(source: str, count: int) -> None:
+    if not is_enabled():
+        return
+    report_event("context.ingest", {"source": source, "count": count})
+
+
+def report_context_search(mode: str, total: int) -> None:
+    if not is_enabled():
+        return
+    report_event("context.search", {"mode": mode, "total": total})

rotalabs_context/_version.py

@@ -0,0 +1 @@
+__version__ = "1.0.0"

rotalabs_context/adapters/__init__.py

@@ -0,0 +1 @@
+"""Pipeline adapters for integrating context into existing ETL workflows."""

rotalabs_context/adapters/airflow.py

@@ -0,0 +1,81 @@
+"""Apache Airflow adapter for rotalabs-context.
+
+Provides an Airflow operator that ingests context during DAG execution.
+
+Usage:
+    from rotalabs_context.adapters.airflow import AirflowContextOperator
+
+    ingest_task = AirflowContextOperator(
+        task_id="ingest_context",
+        source="my-etl-pipeline",
+        records_callable=lambda: [{"content": "data", "title": "record"}],
+        tags=["daily", "production"],
+    )
+"""
+
+from __future__ import annotations
+
+from typing import Any, Callable
+
+try:
+    from airflow.models import BaseOperator
+except ImportError:
+    # Stub for when airflow is not installed
+    class BaseOperator:  # type: ignore[no-redef]
+        def __init__(self, **kwargs: Any) -> None:
+            pass
+
+        def execute(self, context: Any) -> Any:
+            raise ImportError("apache-airflow is required. Install with: pip install rotalabs-context[airflow]")
+
+
+class AirflowContextOperator(BaseOperator):
+    """Airflow operator that ingests records into the context engine.
+
+    Parameters
+    ----------
+    source : str
+        Source identifier for the ingested context.
+    records_callable : callable
+        Function that returns a list of record dicts.
+    tags : list[str]
+        Tags to apply.
+    scope : str
+        Visibility scope.
+    api_key : str, optional
+        Rotascale API key. If not provided, uses ROTASCALE_API_KEY env var.
+    """
+
+    def __init__(
+        self,
+        source: str,
+        records_callable: Callable[..., list[dict[str, Any]]],
+        tags: list[str] | None = None,
+        scope: str = "global",
+        api_key: str | None = None,
+        base_url: str = "https://api.rotascale.com",
+        **kwargs: Any,
+    ) -> None:
+        super().__init__(**kwargs)
+        self.source = source
+        self.records_callable = records_callable
+        self.tags = tags or []
+        self.scope = scope
+        self.api_key = api_key
+        self.base_url = base_url
+
+    def execute(self, context: Any) -> dict[str, Any]:
+        import os
+        from rotalabs_context import ContextEngine
+
+        api_key = self.api_key or os.environ.get("ROTASCALE_API_KEY")
+        ctx = ContextEngine(api_key=api_key, base_url=self.base_url)
+
+        records = self.records_callable()
+        result = ctx.ingest(
+            records=records,
+            source=self.source,
+            tags=self.tags,
+            scope=self.scope,
+        )
+        return result.model_dump()

rotalabs_context/backends/__init__.py

@@ -0,0 +1 @@
+"""Pluggable storage backends for rotalabs-context."""

rotalabs_context/backends/base.py

@@ -0,0 +1,34 @@
+"""Abstract backend interface."""
+
+from __future__ import annotations
+
+import abc
+
+from rotalabs_context.models import IngestRecord, IngestResult, SearchResult
+
+
+class Backend(abc.ABC):
+    """Abstract storage backend for the context engine."""
+
+    @abc.abstractmethod
+    def ingest(
+        self,
+        records: list[IngestRecord],
+        source: str,
+        tags: list[str],
+        scope: str,
+        sensitivity: str,
+        generate_embeddings: bool,
+        extract_entities: bool,
+    ) -> IngestResult:
+        ...
+
+    @abc.abstractmethod
+    def search(
+        self,
+        query: str,
+        top_k: int,
+        mode: str,
+        filters: dict,
+    ) -> SearchResult:
+        ...

rotalabs_context/backends/memory.py

@@ -0,0 +1,136 @@
+"""In-memory backend for local development and testing."""
+
+from __future__ import annotations
+
+import hashlib
+import re
+import time
+from datetime import datetime, timezone
+
+from rotalabs_context.backends.base import Backend
+from rotalabs_context.models import (
+    ContextEntry,
+    IngestRecord,
+    IngestResult,
+    SearchHit,
+    SearchResult,
+)
+
+
+class MemoryBackend(Backend):
+    """In-memory context store. Data is lost when process exits.
+
+    Good for testing, prototyping, and local development.
+    """
+
+    def __init__(self) -> None:
+        self._entries: list[ContextEntry] = []
+        self._counter = 0
+
+    def ingest(
+        self,
+        records: list[IngestRecord],
+        source: str,
+        tags: list[str],
+        scope: str,
+        sensitivity: str,
+        generate_embeddings: bool,
+        extract_entities: bool,
+    ) -> IngestResult:
+        entry_ids: list[str] = []
+        for record in records:
+            self._counter += 1
+            entry_id = f"ctx_{self._counter:06d}"
+            content_hash = hashlib.sha256(record.content.encode()).hexdigest()
+
+            entry = ContextEntry(
+                id=entry_id,
+                source=source,
+                source_id=record.source_id,
+                content_type=record.content_type,
+                title=record.title,
+                content=record.content,
+                content_hash=content_hash,
+                tags=tags,
+                scope=scope,
+                sensitivity=sensitivity,
+                metadata=record.metadata,
+                created_at=datetime.now(timezone.utc),
+            )
+            self._entries.append(entry)
+            entry_ids.append(entry_id)
+
+        return IngestResult(
+            entries_created=len(records),
+            embeddings_generated=0,  # No embeddings in memory mode
+            entities_extracted=0,
+            entry_ids=entry_ids,
+        )
+
+    def search(
+        self,
+        query: str,
+        top_k: int,
+        mode: str,
+        filters: dict,
+    ) -> SearchResult:
+        start = time.monotonic()
+        query_lower = query.lower()
+        query_tokens = set(re.findall(r"[a-z0-9]+", query_lower))
+
+        scored: list[SearchHit] = []
+        for entry in self._entries:
+            # Apply filters
+            if filters.get("tags"):
+                if not any(t in entry.tags for t in filters["tags"]):
+                    continue
+            if filters.get("sources"):
+                if entry.source not in filters["sources"]:
+                    continue
+            if filters.get("scopes"):
+                if entry.scope not in filters["scopes"]:
+                    continue
+
+            # Keyword matching
+            text = f"{entry.title or ''} {entry.content}".lower()
+            text_tokens = set(re.findall(r"[a-z0-9]+", text))
+
+            if not query_tokens:
+                continue
+
+            overlap = query_tokens & text_tokens
+            if not overlap:
+                continue
+
+            score = len(overlap) / len(query_tokens)
+
+            # Extract highlights
+            highlights: list[str] = []
+            for sentence in re.split(r"[.!?\n]+", entry.content):
+                sentence = sentence.strip()
+                if not sentence:
+                    continue
+                sent_tokens = set(re.findall(r"[a-z0-9]+", sentence.lower()))
+                if query_tokens & sent_tokens:
+                    highlights.append(sentence[:200])
+                    if len(highlights) >= 3:
+                        break
+
+            scored.append(SearchHit(
+                entry=entry,
+                score=round(score, 4),
+                highlights=highlights,
+                match_type="keyword",
+            ))
+
+        scored.sort(key=lambda x: x.score, reverse=True)
+        results = scored[:top_k]
+        took_ms = round((time.monotonic() - start) * 1000, 2)
+
+        return SearchResult(
+            query=query,
+            mode=mode,
+            results=results,
+            total=len(results),
+            took_ms=took_ms,
+        )

rotalabs_context/backends/platform.py

@@ -0,0 +1,99 @@
+"""Rotascale platform backend — connects to the managed API."""
+
+from __future__ import annotations
+
+from rotalabs_context.backends.base import Backend
+from rotalabs_context.models import (
+    ContextEntry,
+    IngestRecord,
+    IngestResult,
+    SearchHit,
+    SearchResult,
+)
+
+
+class PlatformBackend(Backend):
+    """Backend that connects to the Rotascale platform API.
+
+    Requires ``httpx`` (install with ``pip install rotalabs-context[platform]``).
+    """
+
+    def __init__(self, api_key: str | None, base_url: str) -> None:
+        try:
+            import httpx
+        except ImportError:
+            raise ImportError(
+                "httpx is required for platform mode. "
+                "Install with: pip install rotalabs-context[platform]"
+            )
+        self._client = httpx.Client(
+            base_url=base_url,
+            headers={
+                "Authorization": f"Bearer {api_key}",
+                "Content-Type": "application/json",
+                "User-Agent": "rotalabs-context/1.0.0",
+            },
+            timeout=30.0,
+        )
+
+    def ingest(
+        self,
+        records: list[IngestRecord],
+        source: str,
+        tags: list[str],
+        scope: str,
+        sensitivity: str,
+        generate_embeddings: bool,
+        extract_entities: bool,
+    ) -> IngestResult:
+        resp = self._client.post(
+            "/v1/context-engine/ingest",
+            json={
+                "records": [r.model_dump() for r in records],
+                "source": source,
+                "tags": tags,
+                "scope": scope,
+                "sensitivity": sensitivity,
+                "generate_embeddings": generate_embeddings,
+                "extract_entities": extract_entities,
+            },
+        )
+        resp.raise_for_status()
+        data = resp.json()
+        return IngestResult(**data)
+
+    def search(
+        self,
+        query: str,
+        top_k: int,
+        mode: str,
+        filters: dict,
+    ) -> SearchResult:
+        resp = self._client.post(
+            "/v1/context-engine/search",
+            json={
+                "query": query,
+                "top_k": top_k,
+                "mode": mode,
+                "filters": filters or None,
+            },
+        )
+        resp.raise_for_status()
+        data = resp.json()
+
+        results = []
+        for hit in data.get("results", []):
+            results.append(SearchHit(
+                entry=ContextEntry(**hit["entry"]),
+                score=hit["score"],
+                highlights=hit.get("highlights", []),
+                match_type=hit.get("match_type", mode),
+            ))
+
+        return SearchResult(
+            query=data["query"],
+            mode=data["mode"],
+            results=results,
+            total=data["total"],
+            took_ms=data.get("took_ms", 0),
+        )

rotalabs_context/engine.py

@@ -0,0 +1,247 @@
+"""ContextEngine — main entry point for rotalabs-context."""
+
+from __future__ import annotations
+
+import hashlib
+import logging
+from typing import Any, Callable
+
+from rotalabs_context.models import (
+    ContextEntry,
+    IngestRecord,
+    IngestResult,
+    SearchHit,
+    SearchResult,
+    Subscription,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class ContextEngine:
+    """Context intelligence engine.
+
+    Provides ingest, search, and subscribe capabilities. Works in two modes:
+
+    - **Local mode** (default): Uses an in-memory or SQLite backend for
+      zero-config local development.
+    - **Platform mode**: Connects to the Rotascale platform API for
+      managed context intelligence with embedding generation, entity
+      extraction, ACLs, and real-time subscriptions.
+
+    Parameters
+    ----------
+    api_key : str, optional
+        Rotascale API key. If provided, enables platform mode.
+    base_url : str
+        Base URL for the Rotascale API.
+    backend : str
+        Backend to use: "memory" (default), "sqlite", or "platform".
+
+    Examples
+    --------
+    >>> ctx = ContextEngine()
+    >>> ctx.ingest(records=[{"content": "hello"}], source="test")
+    >>> results = ctx.search("hello")
+    """
+
+    def __init__(
+        self,
+        api_key: str | None = None,
+        base_url: str = "https://api.rotascale.com",
+        backend: str | None = None,
+    ) -> None:
+        self.api_key = api_key
+        self.base_url = base_url.rstrip("/")
+        self._event_handlers: dict[str, list[dict]] = {}
+
+        # Select backend
+        if backend:
+            self._backend_type = backend
+        elif api_key:
+            self._backend_type = "platform"
+        else:
+            self._backend_type = "memory"
+
+        # Initialize backend
+        if self._backend_type == "platform":
+            from rotalabs_context.backends.platform import PlatformBackend
+            self._backend = PlatformBackend(api_key=api_key, base_url=self.base_url)
+        else:
+            from rotalabs_context.backends.memory import MemoryBackend
+            self._backend = MemoryBackend()
+
+        # Report telemetry
+        _report_init(self._backend_type)
+
+    def ingest(
+        self,
+        records: list[dict[str, Any]],
+        source: str,
+        tags: list[str] | None = None,
+        scope: str = "global",
+        sensitivity: str = "internal",
+        generate_embeddings: bool = True,
+        extract_entities: bool = True,
+    ) -> IngestResult:
+        """Ingest a batch of records into the context store.
+
+        Parameters
+        ----------
+        records : list[dict]
+            Records to ingest. Each must have a "content" key.
+        source : str
+            Source identifier (e.g., "airflow-pipeline", "webhook", "manual").
+        tags : list[str], optional
+            Tags to apply to all records.
+        scope : str
+            Visibility scope (default: "global").
+        sensitivity : str
+            Sensitivity level (default: "internal").
+        generate_embeddings : bool
+            Whether to generate embeddings (platform mode only).
+        extract_entities : bool
+            Whether to extract entities (platform mode only).
+
+        Returns
+        -------
+        IngestResult
+            Summary of the ingestion.
+        """
+        parsed = [IngestRecord(**r) if isinstance(r, dict) else r for r in records]
+        result = self._backend.ingest(
+            records=parsed,
+            source=source,
+            tags=tags or [],
+            scope=scope,
+            sensitivity=sensitivity,
+            generate_embeddings=generate_embeddings,
+            extract_entities=extract_entities,
+        )
+
+        # Fire event handlers
+        self._fire_event("context.created", {
+            "source": source,
+            "entries_created": result.entries_created,
+            "entry_ids": result.entry_ids,
+        })
+
+        _report_ingest(source, result.entries_created)
+        return result
+
+    def search(
+        self,
+        query: str,
+        top_k: int = 20,
+        mode: str = "hybrid",
+        filters: dict[str, Any] | None = None,
+    ) -> SearchResult:
+        """Search the context store.
+
+        Parameters
+        ----------
+        query : str
+            Search query text.
+        top_k : int
+            Maximum results to return.
+        mode : str
+            Search mode: "semantic", "keyword", or "hybrid".
+        filters : dict, optional
+            Filters: tags, sources, scopes, sensitivity, date_from, date_to.
+
+        Returns
+        -------
+        SearchResult
+            Search results with scores and highlights.
+        """
+        result = self._backend.search(
+            query=query,
+            top_k=top_k,
+            mode=mode,
+            filters=filters or {},
+        )
+        _report_search(query, mode, result.total)
+        return result
+
+    def on(
+        self,
+        event_type: str,
+        callback: Callable[..., Any],
+        filter: dict[str, Any] | None = None,
+    ) -> str:
+        """Subscribe to context events.
+
+        Parameters
+        ----------
+        event_type : str
+            Event type to listen for (e.g., "context.created").
+        callback : callable
+            Function to call when event occurs.
+        filter : dict, optional
+            Filter criteria (e.g., {"tags": ["support"]}).
+
+        Returns
+        -------
+        str
+            Subscription ID.
+        """
+        import uuid
+        sub_id = str(uuid.uuid4())[:8]
+        if event_type not in self._event_handlers:
+            self._event_handlers[event_type] = []
+        self._event_handlers[event_type].append({
+            "id": sub_id,
+            "callback": callback,
+            "filter": filter or {},
+        })
+        return sub_id
+
+    def off(self, event_type: str, subscription_id: str) -> None:
+        """Remove an event subscription."""
+        if event_type in self._event_handlers:
+            self._event_handlers[event_type] = [
+                h for h in self._event_handlers[event_type]
+                if h["id"] != subscription_id
+            ]
+
+    def _fire_event(self, event_type: str, data: dict[str, Any]) -> None:
+        """Fire event handlers matching the event type and filters."""
+        for handler in self._event_handlers.get(event_type, []):
+            filter_spec = handler.get("filter", {})
+            # Check tag filter
+            if "tags" in filter_spec and "tags" in data:
+                if not any(t in data.get("tags", []) for t in filter_spec["tags"]):
+                    continue
+            try:
+                handler["callback"](data)
+            except Exception:
+                logger.exception("Error in event handler for %s", event_type)
+
+
+# ── Telemetry helpers ──────────────────────────────────────────
+
+def _report_init(backend_type: str) -> None:
+    try:
+        from rotalabs._telemetry import is_enabled, report_event
+        if is_enabled():
+            report_event("context.engine.init", {"backend": backend_type})
+    except ImportError:
+        pass
+
+
+def _report_ingest(source: str, count: int) -> None:
+    try:
+        from rotalabs._telemetry import is_enabled, report_event
+        if is_enabled():
+            report_event("context.ingest", {"source": source, "count": count})
+    except ImportError:
+        pass
+
+
+def _report_search(query: str, mode: str, total: int) -> None:
+    try:
+        from rotalabs._telemetry import is_enabled, report_event
+        if is_enabled():
+            report_event("context.search", {"mode": mode, "total": total})
+    except ImportError:
+        pass

rotalabs_context/models.py

@@ -0,0 +1,99 @@
+"""Data models for rotalabs-context."""
+
+from __future__ import annotations
+
+import enum
+from datetime import datetime
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+
+class Scope(str, enum.Enum):
+    """Visibility scope for context entries."""
+    GLOBAL = "global"
+    TEAM = "team"
+    AGENT = "agent"
+    PROJECT = "project"
+    USER = "user"
+
+
+class Sensitivity(str, enum.Enum):
+    """Sensitivity classification for context entries."""
+    PUBLIC = "public"
+    INTERNAL = "internal"
+    CONFIDENTIAL = "confidential"
+    RESTRICTED = "restricted"
+
+
+class ContextEntry(BaseModel):
+    """A single context entry in the store."""
+    id: str
+    source: str
+    source_id: str | None = None
+    content_type: str = "text"
+    title: str | None = None
+    content: str
+    content_hash: str
+    tags: list[str] = Field(default_factory=list)
+    scope: str = "global"
+    sensitivity: str = "internal"
+    metadata: dict[str, Any] = Field(default_factory=dict)
+    created_at: datetime | None = None
+
+
+class SearchHit(BaseModel):
+    """A single search result."""
+    entry: ContextEntry
+    score: float
+    highlights: list[str] = Field(default_factory=list)
+    match_type: str = "hybrid"
+
+
+class SearchResult(BaseModel):
+    """Search response containing hits."""
+    query: str
+    mode: str
+    results: list[SearchHit]
+    total: int
+    took_ms: float = 0.0
+
+
+class IngestResult(BaseModel):
+    """Result of a batch ingest operation."""
+    entries_created: int
+    embeddings_generated: int
+    entities_extracted: int
+    entry_ids: list[str] = Field(default_factory=list)
+
+
+class IngestRecord(BaseModel):
+    """A single record to ingest."""
+    content: str
+    title: str | None = None
+    content_type: str = "text"
+    source_id: str | None = None
+    metadata: dict[str, Any] = Field(default_factory=dict)
+
+
+class Subscription(BaseModel):
+    """A context subscription."""
+    id: str
+    subscriber_id: str
+    subscriber_type: str
+    filter_tags: list[str] = Field(default_factory=list)
+    filter_scopes: list[str] = Field(default_factory=list)
+    filter_sources: list[str] = Field(default_factory=list)
+    delivery_method: str
+    webhook_url: str | None = None
+    is_active: bool = True
+
+
+class Entity(BaseModel):
+    """An extracted entity."""
+    id: str
+    name: str
+    entity_type: str
+    source_entry_id: str | None = None
+    metadata: dict[str, Any] = Field(default_factory=dict)
+    mentions_count: int = 1

rotalabs_context-1.0.0.dist-info/METADATA

@@ -0,0 +1,126 @@
+Metadata-Version: 2.4
+Name: rotalabs-context
+Version: 1.0.0
+Summary: Context intelligence for AI agents - Ingest, search, and subscribe to shared context across your AI systems
+Project-URL: Homepage, https://rotalabs.ai
+Project-URL: Repository, https://github.com/rotalabs/rotalabs-context
+Project-URL: Documentation, https://rotalabs.ai/docs/context
+Author-email: Subhadip Mitra <subhadip@rotalabs.ai>, Rotalabs Research <research@rotalabs.ai>
+License-Expression: AGPL-3.0-or-later
+License-File: LICENSE
+Keywords: ai-agents,context,context-engine,embeddings,etl,knowledge-graph,rag,semantic-search
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: GNU Affero General Public License v3 or later (AGPLv3+)
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.9
+Requires-Dist: pydantic>=2.0.0
+Provides-Extra: airflow
+Requires-Dist: apache-airflow>=2.5.0; extra == 'airflow'
+Provides-Extra: all
+Requires-Dist: httpx>=0.25.0; extra == 'all'
+Requires-Dist: numpy>=1.24.0; extra == 'all'
+Requires-Dist: rotalabs[telemetry]>=1.0.0; extra == 'all'
+Requires-Dist: sentence-transformers>=2.2.0; extra == 'all'
+Provides-Extra: dev
+Requires-Dist: mypy>=1.5.0; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.21.0; extra == 'dev'
+Requires-Dist: pytest-cov>=4.1.0; extra == 'dev'
+Requires-Dist: pytest>=7.4.0; extra == 'dev'
+Requires-Dist: ruff>=0.1.0; extra == 'dev'
+Provides-Extra: local
+Requires-Dist: numpy>=1.24.0; extra == 'local'
+Requires-Dist: sentence-transformers>=2.2.0; extra == 'local'
+Provides-Extra: platform
+Requires-Dist: httpx>=0.25.0; extra == 'platform'
+Provides-Extra: telemetry
+Requires-Dist: rotalabs[telemetry]>=1.0.0; extra == 'telemetry'
+Description-Content-Type: text/markdown
+
+# rotalabs-context
+
+> Context intelligence for AI agents — Ingest, search, and subscribe to shared context across your AI systems.
+
+Part of the [Rotalabs](https://rotalabs.ai) trust intelligence research ecosystem.
+
+## Installation
+
+```bash
+pip install rotalabs-context
+```
+
+With local embedding support:
+```bash
+pip install rotalabs-context[local]
+```
+
+With Rotascale platform integration:
+```bash
+pip install rotalabs-context[platform]
+```
+
+## Quick Start
+
+```python
+from rotalabs_context import ContextEngine
+
+# Local mode (zero config, SQLite backend)
+ctx = ContextEngine()
+
+# Platform mode (connects to Rotascale)
+ctx = ContextEngine(
+    api_key="rot_...",
+    base_url="https://api.rotascale.com",
+)
+
+# Ingest context
+result = ctx.ingest(
+    records=[
+        {"content": "User reported login issue", "title": "Support ticket #1234"},
+        {"content": "Auth service latency spike at 2pm UTC", "title": "Incident report"},
+    ],
+    source="helpdesk",
+    tags=["support", "auth"],
+    scope="team:support",
+)
+
+# Search
+results = ctx.search("login issues", top_k=5, mode="semantic")
+for hit in results:
+    print(f"{hit.score:.2f} — {hit.title}")
+
+# Subscribe to context updates
+ctx.on("context.created", filter={"tags": ["support"]}, callback=my_handler)
+```
+
+## Features
+
+- **Ingest**: Push data from any pipeline; we add the "C" (embeddings, entities, relationships)
+- **Search**: Semantic + keyword + hybrid search across all ingested context
+- **Subscribe**: Real-time context propagation via events
+- **ACLs**: Scope-based access control (global, team, agent, project, user)
+- **Pluggable backends**: SQLite (local), PostgreSQL (self-hosted), Rotascale Platform (managed)
+
+## Pipeline Adapters
+
+```python
+# Airflow
+from rotalabs_context.adapters import AirflowContextOperator
+
+# In your DAG
+ingest_task = AirflowContextOperator(
+    task_id="ingest_to_context",
+    source="airflow-etl",
+    tags=["daily-batch"],
+)
+```
+
+## License
+
+AGPL-3.0 — See [LICENSE](LICENSE) for details.

rotalabs_context-1.0.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+rotalabs_context/__init__.py,sha256=NyCfzb7QDx6WCsLSk6tPqWqzHy4D9wi_t6fk61lMDKQ,813
+rotalabs_context/_telemetry.py,sha256=_orcKtb2a0Wz923O_68_ctggcStRufaE-UBrlPD4bXk,879
+rotalabs_context/_version.py,sha256=J-j-u0itpEFT6irdmWmixQqYMadNl1X91TxUmoiLHMI,22
+rotalabs_context/engine.py,sha256=kl_esUPUrtjkqBzt8suHkK7066c8wyk7IzH2J6DNJtg,7691
+rotalabs_context/models.py,sha256=5xkkZVPiwOc6ol4AfMY7kOEKogzKA2sMSxegyv7gyjE,2460
+rotalabs_context/adapters/__init__.py,sha256=ufd8HaKQAk03sxkPIMs-6YOXCOpsZ00bxDObdW627Qs,77
+rotalabs_context/adapters/airflow.py,sha256=vkeiVBCxjPeSEgJtOPBC_tE35laXAw0xZpxCtNrSLHk,2451
+rotalabs_context/backends/__init__.py,sha256=mFsVHMQSSYaXuUfmB_0kJw9iS99QiMJV-afdZFj8aR8,55
+rotalabs_context/backends/base.py,sha256=Uo7VM1zXi1d8wk2bI8wOjXFBgf2n0ANxWJhK5a68-KE,703
+rotalabs_context/backends/memory.py,sha256=jP7IBXa_u-4sFfiJe3B15VHDqPaKRKGAurj30kn4u3A,4072
+rotalabs_context/backends/platform.py,sha256=7R0Y_3sP-yrMNKIUwHD6a4bnYmWKzV0huvaBb7IxL78,2835
+rotalabs_context-1.0.0.dist-info/METADATA,sha256=zfwpu_3y9oFOWdy6WrrD6XBAyzlk9DXLiRZ22wn6rPg,4110
+rotalabs_context-1.0.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+rotalabs_context-1.0.0.dist-info/licenses/LICENSE,sha256=NHBABKRQussR78sGiLyZiA98rt-Q2SAvaMwSwFkctGg,105
+rotalabs_context-1.0.0.dist-info/RECORD,,

rotalabs_context-1.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

rotalabs_context-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,3 @@
+GNU Affero General Public License v3.0
+
+See https://www.gnu.org/licenses/agpl-3.0.en.html for full text.