fluctlightdb 0.4.1__tar.gz

fluctlightdb-0.4.1/LICENSE

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

fluctlightdb-0.4.1/PKG-INFO

@@ -0,0 +1,96 @@
+Metadata-Version: 2.4
+Name: fluctlightdb
+Version: 0.4.1
+Summary: Python client for FluctlightDB — brain-native memory for AI agents
+Author-email: Voxmastery <voxmastery@roppashreeganesh.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/voxmastery/FluctlightDB
+Project-URL: Documentation, https://github.com/voxmastery/FluctlightDB/blob/main/docs/GETTING_STARTED.md
+Project-URL: Repository, https://github.com/voxmastery/FluctlightDB
+Project-URL: Issues, https://github.com/voxmastery/FluctlightDB/issues
+Keywords: ai,agents,memory,database,llm,recall
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+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 :: Database
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: native
+Requires-Dist: fluctlightdb-native>=0.4.0; extra == "native"
+Dynamic: license-file
+
+# fluctlightdb
+
+Python client for [FluctlightDB](https://github.com/voxmastery/FluctlightDB) — a brain-native memory store for AI agents.
+
+## Install
+
+```bash
+pip install fluctlightdb
+```
+
+Optional in-process recall (Rust extension, when wheels are available for your platform):
+
+```bash
+pip install "fluctlightdb[native]"
+# or: pip install fluctlightdb-native
+```
+
+No `cargo` or Rust toolchain required for the HTTP client.
+
+## Quick start (HTTP — like `qdrant-client`)
+
+Run a FluctlightDB server (download a [release binary](https://github.com/voxmastery/FluctlightDB/releases) or use your own deployment), then:
+
+```python
+from fluctlightdb import FluctlightClient
+
+client = FluctlightClient(
+    base_url="http://127.0.0.1:8792",
+    api_key="your-key",
+)
+
+client.experience("user prefers dark mode", context="settings")
+print(client.activate_lite("theme preference"))
+```
+
+Or use environment variables:
+
+```bash
+export FLUCTLIGHT_SERVE_URL=http://127.0.0.1:8792
+export FLUCTLIGHT_API_KEY=your-key
+```
+
+```python
+from fluctlightdb import FluctlightClient
+
+client = FluctlightClient.from_env()
+print(client.activate("dark mode"))
+```
+
+## In-process recall (optional)
+
+When `fluctlightdb-native` is installed:
+
+```python
+from fluctlightdb import get_recall_client
+
+brain = get_recall_client("~/.fluctlight/tenants/default/brain")
+print(brain.activate("dark mode"))
+```
+
+## Docs
+
+- [Getting started](https://github.com/voxmastery/FluctlightDB/blob/main/docs/GETTING_STARTED.md)
+- [HTTP API (OpenAPI)](https://github.com/voxmastery/FluctlightDB/blob/main/docs/openapi.yaml)
+
+## License
+
+MIT — see [LICENSE](LICENSE).

fluctlightdb-0.4.1/README.md

@@ -0,0 +1,68 @@
+# fluctlightdb
+
+Python client for [FluctlightDB](https://github.com/voxmastery/FluctlightDB) — a brain-native memory store for AI agents.
+
+## Install
+
+```bash
+pip install fluctlightdb
+```
+
+Optional in-process recall (Rust extension, when wheels are available for your platform):
+
+```bash
+pip install "fluctlightdb[native]"
+# or: pip install fluctlightdb-native
+```
+
+No `cargo` or Rust toolchain required for the HTTP client.
+
+## Quick start (HTTP — like `qdrant-client`)
+
+Run a FluctlightDB server (download a [release binary](https://github.com/voxmastery/FluctlightDB/releases) or use your own deployment), then:
+
+```python
+from fluctlightdb import FluctlightClient
+
+client = FluctlightClient(
+    base_url="http://127.0.0.1:8792",
+    api_key="your-key",
+)
+
+client.experience("user prefers dark mode", context="settings")
+print(client.activate_lite("theme preference"))
+```
+
+Or use environment variables:
+
+```bash
+export FLUCTLIGHT_SERVE_URL=http://127.0.0.1:8792
+export FLUCTLIGHT_API_KEY=your-key
+```
+
+```python
+from fluctlightdb import FluctlightClient
+
+client = FluctlightClient.from_env()
+print(client.activate("dark mode"))
+```
+
+## In-process recall (optional)
+
+When `fluctlightdb-native` is installed:
+
+```python
+from fluctlightdb import get_recall_client
+
+brain = get_recall_client("~/.fluctlight/tenants/default/brain")
+print(brain.activate("dark mode"))
+```
+
+## Docs
+
+- [Getting started](https://github.com/voxmastery/FluctlightDB/blob/main/docs/GETTING_STARTED.md)
+- [HTTP API (OpenAPI)](https://github.com/voxmastery/FluctlightDB/blob/main/docs/openapi.yaml)
+
+## License
+
+MIT — see [LICENSE](LICENSE).

fluctlightdb-0.4.1/fluctlightdb/__init__.py

@@ -0,0 +1,289 @@
+"""FluctlightDB Python client — agent memory HTTP API."""
+
+from __future__ import annotations
+
+import http.client
+import json
+import os
+import urllib.error
+import urllib.parse
+import urllib.request
+from dataclasses import dataclass, field
+from typing import Any, Optional
+
+from .worker import FluctlightNative, FluctlightWorker, get_recall_client, get_worker
+
+__all__ = [
+    "FluctlightClient",
+    "FluctlightNative",
+    "FluctlightWorker",
+    "get_recall_client",
+    "get_worker",
+]
+
+
+@dataclass
+class FluctlightClient:
+    base_url: str = "http://127.0.0.1:8792"
+    api_key: str = ""
+    timeout: float = 60.0
+    _http: Optional[http.client.HTTPConnection] = field(default=None, repr=False, compare=False)
+
+    @classmethod
+    def from_env(cls) -> "FluctlightClient":
+        return cls(
+            base_url=os.environ.get("FLUCTLIGHT_SERVE_URL", "http://127.0.0.1:8792").rstrip("/"),
+            api_key=os.environ.get("FLUCTLIGHT_API_KEY", ""),
+            timeout=float(os.environ.get("FLUCTLIGHT_HTTP_TIMEOUT", "60")),
+        )
+
+    def _headers(self) -> dict[str, str]:
+        headers = {"Content-Type": "application/json", "Connection": "keep-alive"}
+        if self.api_key:
+            headers["Authorization"] = f"Bearer {self.api_key}"
+        return headers
+
+    def _conn(self) -> http.client.HTTPConnection:
+        if self._http is not None:
+            return self._http
+        parsed = urllib.parse.urlparse(self.base_url)
+        host = parsed.hostname or "127.0.0.1"
+        port = parsed.port or (443 if parsed.scheme == "https" else 80)
+        if parsed.scheme == "https":
+            self._http = http.client.HTTPSConnection(host, port, timeout=self.timeout)
+        else:
+            self._http = http.client.HTTPConnection(host, port, timeout=self.timeout)
+        return self._http
+
+    def _post(self, path: str, payload: Optional[dict[str, Any]] = None) -> dict[str, Any]:
+        body = json.dumps(payload or {})
+        headers = self._headers()
+        try:
+            conn = self._conn()
+            conn.request("POST", path, body=body, headers=headers)
+            resp = conn.getresponse()
+            raw = resp.read().decode("utf-8")
+            if resp.status >= 400:
+                raise RuntimeError(f"Fluctlight HTTP {resp.status}: {raw}")
+            return json.loads(raw) if raw else {}
+        except (http.client.HTTPException, OSError, RuntimeError):
+            self._http = None
+            url = f"{self.base_url}{path}"
+            req = urllib.request.Request(
+                url, data=body.encode("utf-8"), headers=self._headers(), method="POST"
+            )
+            try:
+                with urllib.request.urlopen(req, timeout=self.timeout) as resp:
+                    text = resp.read().decode("utf-8")
+                    return json.loads(text) if text else {}
+            except urllib.error.HTTPError as e:
+                err_body = e.read().decode("utf-8", errors="replace")
+                raise RuntimeError(f"Fluctlight HTTP {e.code}: {err_body}") from e
+
+    def health(self) -> bool:
+        req = urllib.request.Request(f"{self.base_url}/health", method="GET")
+        try:
+            with urllib.request.urlopen(req, timeout=min(self.timeout, 5.0)) as resp:
+                return resp.status == 200
+        except Exception:
+            return False
+
+    def status(self) -> dict[str, Any]:
+        return self._post("/api/v1/status")
+
+    def replica_status(self) -> dict[str, Any]:
+        return self._post("/api/v1/replica-status")
+
+    def experience(
+        self,
+        content: str,
+        context: str = "api",
+        salience: float = 0.5,
+        outcome: Optional[str] = None,
+        semantic_vector: Optional[list[float]] = None,
+        agent_id: Optional[str] = None,
+        doc_id: Optional[str] = None,
+        chunk_id: Optional[str] = None,
+        source_uri: Optional[str] = None,
+        **extra: Any,
+    ) -> dict[str, Any]:
+        payload: dict[str, Any] = {
+            "content": content,
+            "context": context,
+            "salience": salience,
+        }
+        if outcome is not None:
+            payload["outcome"] = outcome
+        if semantic_vector is not None:
+            payload["semantic_vector"] = semantic_vector
+        if agent_id is not None:
+            payload["agent_id"] = agent_id
+        if doc_id is not None:
+            payload["doc_id"] = doc_id
+        if chunk_id is not None:
+            payload["chunk_id"] = chunk_id
+        if source_uri is not None:
+            payload["source_uri"] = source_uri
+        payload.update(extra)
+        return self._post("/api/v1/experience", payload)
+
+    def ingest_chunk(
+        self,
+        content: str,
+        doc_id: str,
+        chunk_id: str,
+        source_uri: Optional[str] = None,
+        semantic_vector: Optional[list[float]] = None,
+        salience: float = 0.55,
+        agent_id: Optional[str] = None,
+        outcome: Optional[str] = None,
+    ) -> dict[str, Any]:
+        payload: dict[str, Any] = {
+            "content": content,
+            "doc_id": doc_id,
+            "chunk_id": chunk_id,
+            "salience": salience,
+        }
+        if source_uri:
+            payload["source_uri"] = source_uri
+        if semantic_vector is not None:
+            payload["semantic_vector"] = semantic_vector
+        if agent_id:
+            payload["agent_id"] = agent_id
+        if outcome:
+            payload["outcome"] = outcome
+        return self._post("/api/v1/ingest-chunk", payload)
+
+    def activate(
+        self,
+        cue: str,
+        semantic_vector: Optional[list[float]] = None,
+        agent_id: Optional[str] = None,
+    ) -> dict[str, Any]:
+        payload: dict[str, Any] = {"cue": cue}
+        if semantic_vector is not None:
+            payload["semantic_vector"] = semantic_vector
+        if agent_id is not None:
+            payload["agent_id"] = agent_id
+        return self._post("/api/v1/activate", payload)
+
+    def activate_lite(
+        self,
+        cue: str,
+        semantic_vector: Optional[list[float]] = None,
+        agent_id: Optional[str] = None,
+    ) -> dict[str, Any]:
+        """Top-1 recall — minimal JSON (~200 B) for HTTP agent hot paths."""
+        payload: dict[str, Any] = {"cue": cue, "limit": 1}
+        if semantic_vector is not None:
+            payload["semantic_vector"] = semantic_vector
+        if agent_id is not None:
+            payload["agent_id"] = agent_id
+        return self._post("/api/v1/activate-lite", payload)
+
+    def activate_batch(
+        self,
+        items: list[dict[str, Any]],
+    ) -> dict[str, Any]:
+        return self._post("/api/v1/activate-batch", {"batch": items})
+
+    def query(self, op: dict[str, Any]) -> dict[str, Any]:
+        return self._post("/api/v1/query", {"query": op})
+
+    def search_by_rag(
+        self,
+        doc_id: str,
+        chunk_id: Optional[str] = None,
+        page: int = 0,
+        page_size: int = 50,
+    ) -> dict[str, Any]:
+        q: dict[str, Any] = {
+            "op": "search_by_rag",
+            "doc_id": doc_id,
+            "page": page,
+            "page_size": page_size,
+        }
+        if chunk_id is not None:
+            q["chunk_id"] = chunk_id
+        return self.query(q)
+
+    def tick(self, n: int = 1) -> Any:
+        return self._post("/api/v1/tick", {"n": int(n)})
+
+    def compact(self) -> dict[str, Any]:
+        return self._post("/api/v1/compact")
+
+    def export_viz(self) -> dict[str, Any]:
+        return self._post("/api/v1/export-viz")
+
+    def export_graph(self, *, lite: bool = False) -> dict[str, Any]:
+        path = "/api/v1/export-graph-lite" if lite else "/api/v1/export-graph"
+        return self._post(path)
+
+    def export_raw(self) -> dict[str, Any]:
+        return self._post("/api/v1/export-raw")
+
+    def reward(self, magnitude: float = 0.5) -> dict[str, Any]:
+        return self._post("/api/v1/reward", {"magnitude": float(magnitude)})
+
+    def death(self, cause: str = "api") -> dict[str, Any]:
+        return self._post("/api/v1/death", {"cause": cause[:200]})
+
+    def mark_core(self, engram_id: str, key: str = "core") -> dict[str, Any]:
+        return self._post("/api/v1/mark-core", {"engram_id": str(engram_id), "key": key})
+
+    def verify_fact(
+        self,
+        engram_id: str,
+        *,
+        provenance_kind: str = "ledger_verified",
+        source_uri: Optional[str] = None,
+        confidence: float = 0.95,
+    ) -> dict[str, Any]:
+        payload: dict[str, Any] = {
+            "engram_id": str(engram_id),
+            "provenance_kind": provenance_kind,
+            "confidence": confidence,
+        }
+        if source_uri:
+            payload["source_uri"] = source_uri
+        return self._post("/api/v1/verify-fact", payload)
+
+    def ground_wallet(
+        self,
+        balance: float,
+        level: int = 1,
+        wallet_path: Optional[str] = None,
+    ) -> dict[str, Any]:
+        uri = wallet_path or "file://wallet.json"
+        content = (
+            f"ledger verified: agent wallet balance is ${balance:.2f} at level {level} "
+            f"(source: wallet.json — ground truth, not chat memory)"
+        )
+        rep = self.experience(
+            content[:500],
+            context="ledger:wallet",
+            salience=0.98,
+            doc_id="ledger",
+            chunk_id="wallet-balance",
+            source_uri=uri,
+            verified=True,
+            provenance_kind="ledger_verified",
+            confidence=0.99,
+        )
+        eid = rep.get("engram_id")
+        if eid and not rep.get("deduplicated"):
+            self.mark_core(str(eid), "ledger-wallet-balance")
+        return rep
+
+    def preplay(self, goal: str, steps: int = 4) -> dict[str, Any]:
+        return self._post("/api/v1/preplay", {"goal": goal, "steps": int(steps)})
+
+    def neurogenesis(self) -> dict[str, Any]:
+        return self._post("/api/v1/neurogenesis", {})
+
+    def verified_context(self, limit: int = 12) -> dict[str, Any]:
+        return self._post("/api/v1/verified-context", {"limit": int(limit)})
+
+    def stage_report(self) -> dict[str, Any]:
+        return self._post("/api/v1/stage-report", {})

fluctlightdb-0.4.1/fluctlightdb/worker.py

@@ -0,0 +1,233 @@
+"""Persistent in-process recall — native library (best) or worker subprocess."""
+
+from __future__ import annotations
+
+import json
+import os
+import shutil
+import subprocess
+import threading
+from pathlib import Path
+from typing import Any, Optional, Protocol
+
+
+def _default_fluctlight_bin() -> str:
+    env = os.environ.get("FLUCTLIGHT_BIN")
+    if env:
+        return env
+    repo_root = Path(__file__).resolve().parents[3]
+    release = repo_root / "target" / "release" / "fluctlight"
+    if release.is_file():
+        return str(release)
+    debug = repo_root / "target" / "debug" / "fluctlight"
+    if debug.is_file():
+        return str(debug)
+    found = shutil.which("fluctlight")
+    return found if found else "fluctlight"
+
+
+class RecallClient(Protocol):
+    def activate(
+        self,
+        cue: str,
+        semantic_vector: Optional[list[float]] = None,
+        agent_id: Optional[str] = None,
+        limit: Optional[int] = None,
+    ) -> dict[str, Any]: ...
+
+    def activate_batch(
+        self,
+        items: list[dict[str, Any]],
+        limit: Optional[int] = None,
+    ) -> dict[str, Any]: ...
+
+    def status(self) -> dict[str, Any]: ...
+
+    def verified_context(self, limit: int = 12) -> dict[str, Any]: ...
+
+
+class FluctlightNative:
+    """Direct Rust library call via PyO3 — same process as Python (like sqlite3)."""
+
+    def __init__(self, brain_path: str, readonly: bool = True) -> None:
+        import fluctlightdb_native as native  # type: ignore
+
+        self._native = native
+        if readonly:
+            self._brain = native.Brain.open_readonly(brain_path)
+        else:
+            self._brain = native.Brain.open(brain_path)
+        self.brain_path = brain_path
+
+    def activate(
+        self,
+        cue: str,
+        semantic_vector: Optional[list[float]] = None,
+        agent_id: Optional[str] = None,
+        limit: Optional[int] = None,
+    ) -> dict[str, Any]:
+        return self._brain.activate(cue, semantic_vector, agent_id, limit)
+
+    def activate_batch(
+        self,
+        items: list[dict[str, Any]],
+        limit: Optional[int] = None,
+    ) -> dict[str, Any]:
+        return self._brain.activate_batch_json(json.dumps(items), limit)
+
+    def status(self) -> dict[str, Any]:
+        return self._brain.status()
+
+    def verified_context(self, limit: int = 12) -> dict[str, Any]:
+        return self._brain.verified_context(limit)
+
+    def has_sidecar_index(self) -> bool:
+        return bool(self._brain.has_sidecar_index())
+
+
+class FluctlightWorker:
+    """Long-lived `fluctlight worker` subprocess — brain loaded once, sub-ms recall."""
+
+    def __init__(
+        self,
+        brain_path: str,
+        bin_path: Optional[str] = None,
+    ) -> None:
+        self.brain_path = brain_path
+        self.bin_path = bin_path or _default_fluctlight_bin()
+        self._lock = threading.Lock()
+        self._id = 0
+        self._proc: Optional[subprocess.Popen[str]] = None
+        self._start()
+
+    def _start(self) -> None:
+        if not os.path.isfile(self.bin_path):
+            raise FileNotFoundError(self.bin_path)
+        self._proc = subprocess.Popen(
+            [self.bin_path, "worker", "--path", self.brain_path],
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+            bufsize=1,
+        )
+        if self._proc.stdin is None or self._proc.stdout is None:
+            raise RuntimeError("worker pipes unavailable")
+
+    def close(self) -> None:
+        with self._lock:
+            if self._proc and self._proc.poll() is None:
+                try:
+                    self._call("shutdown")
+                except Exception:
+                    pass
+                self._proc.terminate()
+            self._proc = None
+
+    def _call(self, op: str, **kwargs: Any) -> dict[str, Any]:
+        with self._lock:
+            if self._proc is None or self._proc.poll() is not None:
+                self._start()
+            assert self._proc is not None
+            assert self._proc.stdin is not None
+            assert self._proc.stdout is not None
+            self._id += 1
+            req = {"op": op, "id": self._id, **kwargs}
+            self._proc.stdin.write(json.dumps(req) + "\n")
+            self._proc.stdin.flush()
+            line = self._proc.stdout.readline()
+            if not line:
+                err = (self._proc.stderr.read() if self._proc.stderr else "")[:300]
+                raise RuntimeError(f"worker closed: {err}")
+            resp = json.loads(line)
+            if not resp.get("ok"):
+                raise RuntimeError(resp.get("error") or "worker error")
+            return resp
+
+    def ping(self) -> bool:
+        return bool(self._call("ping").get("pong"))
+
+    def activate(
+        self,
+        cue: str,
+        semantic_vector: Optional[list[float]] = None,
+        agent_id: Optional[str] = None,
+        limit: Optional[int] = None,
+    ) -> dict[str, Any]:
+        payload: dict[str, Any] = {"cue": cue}
+        if semantic_vector is not None:
+            payload["semantic_vector"] = semantic_vector
+        if agent_id is not None:
+            payload["agent_id"] = agent_id
+        if limit is not None:
+            payload["limit"] = limit
+        return self._call("activate", **payload)["result"]
+
+    def activate_batch(
+        self,
+        items: list[dict[str, Any]],
+        limit: Optional[int] = None,
+    ) -> dict[str, Any]:
+        payload: dict[str, Any] = {"batch": items}
+        if limit is not None:
+            payload["limit"] = limit
+        resp = self._call("activate_batch", **payload)
+        return {"results": resp.get("results") or [], "count": resp.get("count", 0)}
+
+    def status(self) -> dict[str, Any]:
+        return self._call("status")["status"]
+
+    def verified_context(self, limit: int = 12) -> dict[str, Any]:
+        return self._call("verified_context", limit=limit)["context"]
+
+    def reload(self) -> dict[str, Any]:
+        return self._call("reload")
+
+
+_worker_singleton: Optional[FluctlightWorker] = None
+_native_singleton: Optional[FluctlightNative] = None
+_client_lock = threading.Lock()
+
+
+def get_recall_client(
+    brain_path: Optional[str] = None,
+    bin_path: Optional[str] = None,
+) -> RecallClient:
+    """Best available in-process recall: native library > worker subprocess."""
+    global _native_singleton, _worker_singleton
+    path = brain_path or os.environ.get(
+        "FLUCTLIGHT_BRAIN",
+        os.environ.get(
+            "FLUCTLIGHT_BRAIN_PATH",
+            os.path.expanduser("~/.fluctlight/tenants/default/brain"),
+        ),
+    )
+    prefer_native = os.environ.get("FLUCTLIGHT_NATIVE", "1").lower() not in (
+        "0",
+        "false",
+        "no",
+    )
+    with _client_lock:
+        if prefer_native and _native_singleton is None:
+            try:
+                _native_singleton = FluctlightNative(path, readonly=True)
+                return _native_singleton
+            except ImportError:
+                pass
+            except Exception:
+                _native_singleton = None
+        if _native_singleton is not None:
+            return _native_singleton
+        if _worker_singleton is None:
+            _worker_singleton = FluctlightWorker(path, bin_path=bin_path)
+        return _worker_singleton
+
+
+def get_worker(
+    brain_path: Optional[str] = None,
+    bin_path: Optional[str] = None,
+) -> FluctlightWorker:
+    client = get_recall_client(brain_path=brain_path, bin_path=bin_path)
+    if isinstance(client, FluctlightWorker):
+        return client
+    raise TypeError("native client active — use get_recall_client() instead")

fluctlightdb-0.4.1/fluctlightdb.egg-info/PKG-INFO

@@ -0,0 +1,96 @@
+Metadata-Version: 2.4
+Name: fluctlightdb
+Version: 0.4.1
+Summary: Python client for FluctlightDB — brain-native memory for AI agents
+Author-email: Voxmastery <voxmastery@roppashreeganesh.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/voxmastery/FluctlightDB
+Project-URL: Documentation, https://github.com/voxmastery/FluctlightDB/blob/main/docs/GETTING_STARTED.md
+Project-URL: Repository, https://github.com/voxmastery/FluctlightDB
+Project-URL: Issues, https://github.com/voxmastery/FluctlightDB/issues
+Keywords: ai,agents,memory,database,llm,recall
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+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 :: Database
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: native
+Requires-Dist: fluctlightdb-native>=0.4.0; extra == "native"
+Dynamic: license-file
+
+# fluctlightdb
+
+Python client for [FluctlightDB](https://github.com/voxmastery/FluctlightDB) — a brain-native memory store for AI agents.
+
+## Install
+
+```bash
+pip install fluctlightdb
+```
+
+Optional in-process recall (Rust extension, when wheels are available for your platform):
+
+```bash
+pip install "fluctlightdb[native]"
+# or: pip install fluctlightdb-native
+```
+
+No `cargo` or Rust toolchain required for the HTTP client.
+
+## Quick start (HTTP — like `qdrant-client`)
+
+Run a FluctlightDB server (download a [release binary](https://github.com/voxmastery/FluctlightDB/releases) or use your own deployment), then:
+
+```python
+from fluctlightdb import FluctlightClient
+
+client = FluctlightClient(
+    base_url="http://127.0.0.1:8792",
+    api_key="your-key",
+)
+
+client.experience("user prefers dark mode", context="settings")
+print(client.activate_lite("theme preference"))
+```
+
+Or use environment variables:
+
+```bash
+export FLUCTLIGHT_SERVE_URL=http://127.0.0.1:8792
+export FLUCTLIGHT_API_KEY=your-key
+```
+
+```python
+from fluctlightdb import FluctlightClient
+
+client = FluctlightClient.from_env()
+print(client.activate("dark mode"))
+```
+
+## In-process recall (optional)
+
+When `fluctlightdb-native` is installed:
+
+```python
+from fluctlightdb import get_recall_client
+
+brain = get_recall_client("~/.fluctlight/tenants/default/brain")
+print(brain.activate("dark mode"))
+```
+
+## Docs
+
+- [Getting started](https://github.com/voxmastery/FluctlightDB/blob/main/docs/GETTING_STARTED.md)
+- [HTTP API (OpenAPI)](https://github.com/voxmastery/FluctlightDB/blob/main/docs/openapi.yaml)
+
+## License
+
+MIT — see [LICENSE](LICENSE).

fluctlightdb-0.4.1/fluctlightdb.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+LICENSE
+README.md
+pyproject.toml
+fluctlightdb/__init__.py
+fluctlightdb/worker.py
+fluctlightdb.egg-info/PKG-INFO
+fluctlightdb.egg-info/SOURCES.txt
+fluctlightdb.egg-info/dependency_links.txt
+fluctlightdb.egg-info/requires.txt
+fluctlightdb.egg-info/top_level.txt

fluctlightdb-0.4.1/fluctlightdb.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

fluctlightdb-0.4.1/fluctlightdb.egg-info/requires.txt

@@ -0,0 +1,3 @@
+
+[native]
+fluctlightdb-native>=0.4.0

fluctlightdb-0.4.1/fluctlightdb.egg-info/top_level.txt

@@ -0,0 +1 @@
+fluctlightdb

fluctlightdb-0.4.1/pyproject.toml

@@ -0,0 +1,39 @@
+[build-system]
+requires = ["setuptools>=61", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "fluctlightdb"
+version = "0.4.1"
+description = "Python client for FluctlightDB — brain-native memory for AI agents"
+readme = "README.md"
+requires-python = ">=3.9"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "Voxmastery", email = "voxmastery@roppashreeganesh.com" }]
+keywords = ["ai", "agents", "memory", "database", "llm", "recall"]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Intended Audience :: Developers",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.9",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Topic :: Database",
+  "Topic :: Scientific/Engineering :: Artificial Intelligence",
+  "Typing :: Typed",
+]
+
+[project.urls]
+Homepage = "https://github.com/voxmastery/FluctlightDB"
+Documentation = "https://github.com/voxmastery/FluctlightDB/blob/main/docs/GETTING_STARTED.md"
+Repository = "https://github.com/voxmastery/FluctlightDB"
+Issues = "https://github.com/voxmastery/FluctlightDB/issues"
+
+[project.optional-dependencies]
+native = ["fluctlightdb-native>=0.4.0"]
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["fluctlightdb*"]

fluctlightdb-0.4.1/setup.cfg

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