@privacyscrubber/sdk 2.3.9 → 2.4.0

package/examples/python-bridge/privacyscrubber/langchain.py

@@ -0,0 +1,161 @@
+"""
+PrivacyScrubber LangChain Adapter
+"""
+
+from __future__ import annotations
+
+import copy
+from typing import Any, Dict, List, Optional, Sequence, Union
+
+from privacyscrubber.client import PrivacyScrubberClient
+
+
+try:
+    from langchain_core.callbacks.base import BaseCallbackHandler
+    from langchain_core.documents import Document
+    from langchain_core.outputs import LLMResult
+    from langchain_core.runnables import RunnableLambda
+    LANGCHAIN_INSTALLED = True
+except ImportError:
+    LANGCHAIN_INSTALLED = False
+    BaseCallbackHandler = object  # type: ignore
+    Document = object  # type: ignore
+    LLMResult = object  # type: ignore
+    RunnableLambda = object  # type: ignore
+
+
+class ZTDSCallbackHandler(BaseCallbackHandler):
+    """
+    LangChain Callback Handler enforcing Zero-Trust Data Sanitization.
+    
+    1. Intercepts outgoing prompts in on_llm_start -> replaces raw PII with surrogate tokens.
+    2. Stores ephemeral token mappings in RAM only (no disk, no network).
+    3. Intercepts incoming responses in on_llm_end -> restores cleartext values in RAM.
+    """
+
+    def __init__(
+        self,
+        scrubber: Optional[PrivacyScrubberClient] = None,
+        profile: str = "General",
+        detect_secrets: bool = False,
+        verbose: bool = False
+    ) -> None:
+        self.scrubber = scrubber or PrivacyScrubberClient(default_profile=profile)
+        self.profile = profile
+        self.detect_secrets = detect_secrets
+        self.verbose = verbose
+        self._session_token_maps: Dict[str, Dict[str, str]] = {}
+
+    def on_llm_start(
+        self,
+        serialized: Dict[str, Any],
+        prompts: List[str],
+        *,
+        run_id: Optional[Any] = None,
+        parent_run_id: Optional[Any] = None,
+        tags: Optional[List[str]] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+        **kwargs: Any
+    ) -> Any:
+        """Sanitizes prompts in place before they are dispatched to the cloud LLM."""
+        key = str(run_id) if run_id else "default"
+        combined_token_map: Dict[str, str] = {}
+
+        for i, prompt in enumerate(prompts):
+            res = self.scrubber.sanitize(
+                prompt,
+                profile=self.profile,
+                detect_secrets=self.detect_secrets,
+                persist_session=True
+            )
+            prompts[i] = res.sanitized
+            combined_token_map.update(res.token_map)
+            if self.verbose and res.count > 0:
+                print(f"[ZTDS Guard] Sanitized {res.count} PII tokens for run {key}")
+
+        self._session_token_maps[key] = combined_token_map
+
+    def on_llm_end(
+        self,
+        response: Any,
+        *,
+        run_id: Optional[Any] = None,
+        parent_run_id: Optional[Any] = None,
+        tags: Optional[List[str]] = None,
+        **kwargs: Any
+    ) -> Any:
+        """Restores cleartext tokens in LLM output before reaching the user."""
+        key = str(run_id) if run_id else "default"
+        token_map = self._session_token_maps.pop(key, None)
+
+        generations = getattr(response, "generations", None)
+        if generations and isinstance(generations, list):
+            for gen_list in generations:
+                for gen in gen_list:
+                    if hasattr(gen, "text") and gen.text:
+                        restored = self.scrubber.restore(gen.text, token_map=token_map)
+                        gen.text = restored.restored_text
+                    elif hasattr(gen, "message") and hasattr(gen.message, "content"):
+                        if isinstance(gen.message.content, str):
+                            restored = self.scrubber.restore(gen.message.content, token_map=token_map)
+                            gen.message.content = restored.restored_text
+
+        return response
+
+
+class ZTDSDocumentTransformer:
+    """
+    Sanitizes LangChain Documents before vector database ingestion (Pinecone, Qdrant, Chroma).
+    Guarantees no raw PII enters embeddings or persistent vector storage.
+    """
+
+    def __init__(
+        self,
+        scrubber: Optional[PrivacyScrubberClient] = None,
+        profile: str = "General",
+        sensitive_metadata_keys: Optional[Sequence[str]] = None
+    ) -> None:
+        self.scrubber = scrubber or PrivacyScrubberClient(default_profile=profile)
+        self.profile = profile
+        self.sensitive_metadata_keys = list(sensitive_metadata_keys or [])
+
+    def transform_documents(self, documents: Sequence[Any]) -> List[Any]:
+        """Transforms documents, sanitizing page_content and sensitive metadata keys."""
+        transformed: List[Any] = []
+        for doc in documents:
+            doc_copy = copy.deepcopy(doc)
+            content = getattr(doc_copy, "page_content", "")
+            if isinstance(content, str) and content:
+                res = self.scrubber.sanitize(content, profile=self.profile)
+                doc_copy.page_content = res.sanitized
+
+            metadata = getattr(doc_copy, "metadata", None)
+            if isinstance(metadata, dict):
+                for k in self.sensitive_metadata_keys:
+                    if k in metadata and isinstance(metadata[k], str):
+                        res_meta = self.scrubber.sanitize(metadata[k], profile=self.profile)
+                        metadata[k] = res_meta.sanitized
+
+            transformed.append(doc_copy)
+        return transformed
+
+
+def create_ztds_lcel_runnables(
+    scrubber: Optional[PrivacyScrubberClient] = None,
+    profile: str = "General"
+):
+    """
+    Creates pre-scrub and post-restore runnables for LCEL pipelines:
+    chain = scrub_runnable | prompt | model | parser | restore_runnable
+    """
+    client = scrubber or PrivacyScrubberClient(default_profile=profile)
+
+    def scrub_func(input_text: str) -> str:
+        res = client.sanitize(str(input_text), profile=profile)
+        return res.sanitized
+
+    def restore_func(output_text: str) -> str:
+        restored = client.restore(str(output_text))
+        return restored.restored_text
+
+    return scrub_func, restore_func

package/examples/python-bridge/privacyscrubber/types.py

@@ -0,0 +1,52 @@
+"""
+PrivacyScrubber Data Types & Response Models
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional
+
+
+@dataclass
+class SanitizeResult:
+    """Result of a text sanitization operation."""
+    sanitized: str
+    token_map: Dict[str, str]
+    count: int = 0
+    execution_ms: float = 0.0
+    telemetry: Optional[Dict[str, Any]] = None
+    audit_receipt: Optional[str] = None
+    license: Optional[Dict[str, Any]] = None
+    matches: Optional[List[Dict[str, Any]]] = None
+
+    def __str__(self) -> str:
+        """Allow direct string usage in prompts and string formatting."""
+        return self.sanitized
+
+    @property
+    def scrubbed_text(self) -> str:
+        """Alias for sanitized text."""
+        return self.sanitized
+
+
+@dataclass
+class RestoreResult:
+    """Result of a token restoration operation."""
+    restored_text: str
+    restored_count: int = 0
+
+    def __str__(self) -> str:
+        """Allow direct string usage in final responses."""
+        return self.restored_text
+
+
+@dataclass
+class ObjectSanitizeResult:
+    """Result of a structured dictionary or list sanitization operation."""
+    sanitized: Any
+    token_map: Dict[str, str]
+    count: int = 0
+    execution_ms: float = 0.0
+    telemetry: Optional[Dict[str, Any]] = None
+    audit_receipt: Optional[str] = None

package/examples/python-bridge/privacyscrubber.egg-info/PKG-INFO

@@ -0,0 +1,311 @@
+Metadata-Version: 2.4
+Name: privacyscrubber
+Version: 2.4.0
+Summary: Zero-Trust Data Sanitization & In-Memory PII Shield for Python AI Pipelines (ZTDS RFC v1.0)
+Home-page: https://privacyscrubber.com
+Author: Ilya Sibiryakov (BrandMeWeb)
+Author-email: "Ilya Sibiryakov (BrandMeWeb)" <contact@privacyscrubber.com>
+License: Commercial / Proprietary
+Project-URL: Homepage, https://privacyscrubber.com
+Project-URL: Documentation, https://privacyscrubber.com/sdk/
+Project-URL: Repository, https://github.com/moxno/privacyscrubber-mcp
+Project-URL: Standard, https://datatracker.ietf.org/doc/draft-sibiryakov-ztds-protocol/
+Keywords: pii,redaction,sanitization,zero-trust,ztds,langchain,fastapi,presidio,llm-security,gdpr,hipaa,ai-guardrail
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
+Classifier: Topic :: Security
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+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: Programming Language :: Python :: 3.13
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Provides-Extra: fastapi
+Requires-Dist: fastapi>=0.100.0; extra == "fastapi"
+Requires-Dist: uvicorn>=0.20.0; extra == "fastapi"
+Requires-Dist: pydantic>=2.0.0; extra == "fastapi"
+Provides-Extra: langchain
+Requires-Dist: langchain-core>=0.1.0; extra == "langchain"
+Provides-Extra: llamaindex
+Requires-Dist: llama-index-core>=0.10.0; extra == "llamaindex"
+Provides-Extra: all
+Requires-Dist: fastapi>=0.100.0; extra == "all"
+Requires-Dist: uvicorn>=0.20.0; extra == "all"
+Requires-Dist: pydantic>=2.0.0; extra == "all"
+Requires-Dist: langchain-core>=0.1.0; extra == "all"
+Requires-Dist: llama-index-core>=0.10.0; extra == "all"
+Dynamic: author
+Dynamic: home-page
+Dynamic: requires-python
+
+# PrivacyScrubber Python Bridge (ZTDS Zero-Egress Sidecar)
+
+Sub-millisecond, zero-dependency Python adapter for **PrivacyScrubber SDK** (`@privacyscrubber/sdk`).
+
+Enforces **Zero-Trust Data Sanitization (ZTDS RFC v1.0)** across Python AI and data pipelines:
+- **FastAPI / Flask / Django**: Pre-LLM sanitization and post-LLM in-memory rehydration.
+- **LangChain**: `ZTDSCallbackHandler` and `ZTDSDocumentTransformer`.
+- **LlamaIndex**: Pre-embedding chunk and metadata sanitization.
+- **Raw OpenAI / Anthropic / Gemini SDKs**: Direct string and dictionary tokenization.
+
+---
+
+## Architectural Comparison: PrivacyScrubber vs. Microsoft Presidio
+
+| Metric | Microsoft Presidio | PrivacyScrubber ZTDS Bridge |
+| :--- | :--- | :--- |
+| **Inference Latency** | ~35ms – 65ms per request | **~0.15ms – 0.40ms per request (<1ms SLA)** |
+| **Memory Footprint** | 1.8 GB – 3.2 GB RAM (PyTorch / spaCy) | **< 25 MB RAM (Zero PyTorch / zero spaCy)** |
+| **Python Dependencies** | `presidio-analyzer`, `presidio-anonymizer`, `spacy`, `torch` | **0 Dependencies (Python Standard Library Only)** |
+| **Round-Trip Re-hydration** | Non-trivial (custom hash table mapping required) | **Native 100% Round-Trip (`client.restore()`)** |
+| **Pre-Configured Profiles** | Basic PII only (requires custom YAML recognizers) | **30 Built-in Industry Profiles (HIPAA, Financial, Legal, HR, etc.)** |
+| **Network Egress** | Potential telemetry unless air-gapped | **0.00 Bytes Network Egress (RAM-only volatile mapping)** |
+| **Container Startup** | 15 – 30 seconds model loading time | **< 100 milliseconds** |
+
+---
+
+---
+
+## Installation & Prerequisites
+
+1. Ensure **Node.js** (v18+) and **Python** (3.8+) are available on your system.
+2. Install `@privacyscrubber/sdk`:
+   ```bash
+   npm install @privacyscrubber/sdk
+   ```
+3. Install the Python package via `pip`:
+   ```bash
+   # Editable local development:
+   pip install -e npm-sdk/examples/python-bridge
+
+   # Or standard pip install:
+   pip install ./npm-sdk/examples/python-bridge
+   ```
+   *Note: Zero external Python dependencies are required.*
+
+---
+
+## Command Line Interface (CLI)
+
+The package bundles a terminal CLI utility `privacyscrubber` (alias: `ps-bridge`):
+
+```bash
+# Check ZTDS engine status and uptime
+privacyscrubber ping
+privacyscrubber status
+
+# Sanitize text directly
+privacyscrubber sanitize "Customer Alice Cooper (alice@hospital.org)" --profile Healthcare
+
+# Pipe text through standard input:
+echo "Analyze wire for John Doe john@corp.com" | privacyscrubber sanitize
+
+# Output structured JSON with tokens and compliance telemetry:
+privacyscrubber sanitize "Patient John Doe" --json
+
+# Restore surrogate tokens:
+privacyscrubber restore "Patient [NAME_1]" --token-map '{"[NAME_1]": "John Doe"}'
+```
+
+---
+
+## Quickstart
+
+### 1. Synchronous Client
+
+```python
+from privacyscrubber import PrivacyScrubber
+
+# Initialize sidecar in local RAM (auto-starts daemon)
+with PrivacyScrubber(default_profile="General") as ps:
+    # Sanitize prompt before sending to cloud LLM
+    result = ps.sanitize("Please review intake for patient John Doe (john@acme.com, phone +1-555-0199).")
+    
+    print("Sanitized Prompt:", result.sanitized)
+    # Output: Please review intake for patient [NAME_1] ([EMAIL_1], phone [PHONE_1]).
+    
+    # Simulate LLM operating strictly on tokens
+    ai_response = "I have noted records for [NAME_1] ([EMAIL_1])."
+    
+    # Restore cleartext tokens in local RAM
+    restored = ps.restore(ai_response)
+    print("Restored Answer:", restored.restored_text)
+    # Output: I have noted records for John Doe (john@acme.com).
+```
+
+### 2. Asynchronous Client (FastAPI / asyncio)
+
+```python
+import asyncio
+from privacyscrubber import AsyncPrivacyScrubber
+
+async def main():
+    async with AsyncPrivacyScrubber(default_profile="Healthcare") as ps:
+        res = await ps.sanitize("Patient Alice Cooper (DOB: 1984-05-12, SSN: 000-11-2222).")
+        print("Sanitized:", res.sanitized)
+        # Patient [NAME_1] (DOB: [DATE_1], SSN: [ID_1]).
+        
+        restored = await ps.restore("Prescription confirmed for [NAME_1].")
+        print("Restored:", restored.restored_text)
+
+asyncio.run(main())
+```
+
+---
+
+## Framework Integrations
+
+### FastAPI Zero-Egress Proxy (`fastapi_example.py`)
+
+Run an OpenAI-compatible proxy that guarantees no raw PII ever touches OpenAI or external model APIs:
+
+```python
+from fastapi import FastAPI
+from privacyscrubber import AsyncPrivacyScrubber
+
+app = FastAPI()
+scrubber = AsyncPrivacyScrubber()
+
+@app.on_event("startup")
+async def on_startup():
+    await scrubber.start()
+
+@app.on_event("shutdown")
+async def on_shutdown():
+    await scrubber.close()
+
+@app.post("/v1/chat/completions")
+async def chat_proxy(payload: dict):
+    # 1. Sanitize user prompt in client memory (<0.2ms)
+    messages = payload.get("messages", [])
+    user_prompt = messages[-1]["content"]
+    
+    sanitized = await scrubber.sanitize(user_prompt)
+    messages[-1]["content"] = sanitized.sanitized
+    
+    # 2. Forward sanitized payload to cloud LLM (httpx call)
+    # raw_llm_response = await client.post("https://api.openai.com/v1/chat/completions", json=payload)
+    mock_llm_reply = f"Acknowledged request for {sanitized.sanitized}"
+    
+    # 3. Restore cleartext in RAM before returning to end-user
+    restored = await scrubber.restore(mock_llm_reply, token_map=sanitized.token_map)
+    return {"choices": [{"message": {"role": "assistant", "content": restored.restored_text}}]}
+```
+
+### LangChain (`langchain_adapter.py`)
+
+#### Callback Handler (Transparent Pre/Post LLM Guard)
+```python
+from langchain_openai import ChatOpenAI
+from langchain_adapter import ZTDSCallbackHandler
+
+llm = ChatOpenAI(
+    model="gpt-4o",
+    callbacks=[ZTDSCallbackHandler(profile="Financial")]
+)
+
+# Prompts are automatically sanitized before leaving process memory;
+# LLM outputs are automatically restored before returning to your code.
+response = llm.invoke("What is the credit rating for customer David Miller (SSN 987-65-4321)?")
+print(response.content)
+```
+
+#### Vector Ingestion Guard (Pinecone, Chroma, Qdrant)
+```python
+from langchain_adapter import ZTDSDocumentTransformer
+
+transformer = ZTDSDocumentTransformer(
+    profile="Financial",
+    sensitive_metadata_keys=["customer_email", "account_id"]
+)
+
+# Sanitizes both page_content and sensitive metadata dictionaries
+safe_docs = transformer.transform_documents(raw_docs)
+vector_store.add_documents(safe_docs)
+```
+
+---
+
+## Nested Dictionary & JSON Sanitization
+
+Sanitize complex structured payloads (REST API payloads, MongoDB documents, JSON logs):
+
+```python
+payload = {
+    "user_id": 9012,
+    "customer": {
+        "name": "Sarah Connor",
+        "email": "sconnor@cyberdyne.org",
+        "phones": ["+1-555-0199", "+1-555-0188"]
+    },
+    "status": "active"
+}
+
+# Recursively sanitizes strings, preserving keys and types intact:
+result = ps.sanitize_object(payload)
+print(result.sanitized)
+# {
+#   "user_id": 9012,
+#   "customer": {
+#     "name": "[NAME_1]",
+#     "email": "[EMAIL_1]",
+#     "phones": ["[PHONE_1]", "[PHONE_2]"]
+#   },
+#   "status": "active"
+# }
+
+# Restore structure:
+restored = ps.restore_object(result.sanitized, token_map=result.token_map)
+```
+
+---
+
+## Production Docker Deployment
+
+Deploying Python applications alongside the PrivacyScrubber sidecar in a single multi-runtime container:
+
+```dockerfile
+FROM node:22-bookworm-slim AS node-base
+
+FROM python:3.11-slim-bookworm
+
+# Copy Node.js runtime into Python container
+COPY --from=node-base /usr/local/bin/node /usr/local/bin/node
+COPY --from=node-base /usr/local/lib/node_modules /usr/local/lib/node_modules
+
+WORKDIR /app
+
+# Install SDK bridge
+COPY package*.json ./
+RUN npm install @privacyscrubber/sdk --production
+
+# Install Python requirements
+COPY requirements.txt ./
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+CMD ["uvicorn", "fastapi_example:app", "--host", "0.0.0.0", "--port", "8000"]
+```
+
+---
+
+## Running the Verification Suite
+
+Run all tests, benchmarks, and concurrency assertions:
+
+```bash
+# Automated Test Suite (10 tests, 0.3s)
+python3 test_python_bridge.py
+
+# Interactive Examples
+python3 fastapi_example.py
+python3 langchain_example.py
+python3 llamaindex_example.py
+```

package/examples/python-bridge/privacyscrubber.egg-info/SOURCES.txt

@@ -0,0 +1,18 @@
+MANIFEST.in
+README.md
+bridge_daemon.cjs
+pyproject.toml
+setup.py
+privacyscrubber/__init__.py
+privacyscrubber/bridge_daemon.cjs
+privacyscrubber/cli.py
+privacyscrubber/client.py
+privacyscrubber/exceptions.py
+privacyscrubber/langchain.py
+privacyscrubber/types.py
+privacyscrubber.egg-info/PKG-INFO
+privacyscrubber.egg-info/SOURCES.txt
+privacyscrubber.egg-info/dependency_links.txt
+privacyscrubber.egg-info/entry_points.txt
+privacyscrubber.egg-info/requires.txt
+privacyscrubber.egg-info/top_level.txt

package/examples/python-bridge/privacyscrubber.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

package/examples/python-bridge/privacyscrubber.egg-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+privacyscrubber = privacyscrubber.cli:main
+ps-bridge = privacyscrubber.cli:main

package/examples/python-bridge/privacyscrubber.egg-info/requires.txt

@@ -0,0 +1,18 @@
+
+[all]
+fastapi>=0.100.0
+uvicorn>=0.20.0
+pydantic>=2.0.0
+langchain-core>=0.1.0
+llama-index-core>=0.10.0
+
+[fastapi]
+fastapi>=0.100.0
+uvicorn>=0.20.0
+pydantic>=2.0.0
+
+[langchain]
+langchain-core>=0.1.0
+
+[llamaindex]
+llama-index-core>=0.10.0

package/examples/python-bridge/privacyscrubber.egg-info/top_level.txt

@@ -0,0 +1 @@
+privacyscrubber

package/examples/python-bridge/privacyscrubber.py

@@ -0,0 +1,36 @@
+"""
+PrivacyScrubber ZTDS Client for Python
+Zero-Trust Data Sanitization & Local PII Shield for LLM / AI Pipelines.
+
+100% in-memory client-side execution. Zero cloud egress. Sub-millisecond latency.
+RFC v1.0 standard-compliant Zero-Trust Data Sanitization engine.
+"""
+
+from __future__ import annotations
+
+from privacyscrubber import (
+    PrivacyScrubberClient,
+    PrivacyScrubber,
+    AsyncPrivacyScrubberClient,
+    AsyncPrivacyScrubber,
+    SanitizeResult,
+    RestoreResult,
+    ObjectSanitizeResult,
+    PrivacyScrubberError,
+    PrivacyScrubberLicenseError,
+    __version__,
+)
+from privacyscrubber.client import _find_daemon_path
+
+__all__ = [
+    "PrivacyScrubberClient",
+    "PrivacyScrubber",
+    "AsyncPrivacyScrubberClient",
+    "AsyncPrivacyScrubber",
+    "SanitizeResult",
+    "RestoreResult",
+    "ObjectSanitizeResult",
+    "PrivacyScrubberError",
+    "PrivacyScrubberLicenseError",
+    "__version__",
+]

package/examples/python-bridge/pyproject.toml

@@ -0,0 +1,62 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "privacyscrubber"
+version = "2.4.0"
+description = "Zero-Trust Data Sanitization & In-Memory PII Shield for Python AI Pipelines (ZTDS RFC v1.0)"
+readme = "README.md"
+requires-python = ">=3.8"
+license = { text = "Commercial / Proprietary" }
+authors = [
+    { name = "Ilya Sibiryakov (BrandMeWeb)", email = "contact@privacyscrubber.com" }
+]
+keywords = [
+    "pii", "redaction", "sanitization", "zero-trust", "ztds", "langchain",
+    "fastapi", "presidio", "llm-security", "gdpr", "hipaa", "ai-guardrail"
+]
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Information Technology",
+    "Topic :: Security",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Operating System :: OS Independent",
+]
+
+[project.urls]
+Homepage = "https://privacyscrubber.com"
+Documentation = "https://privacyscrubber.com/sdk/"
+Repository = "https://github.com/moxno/privacyscrubber-mcp"
+Standard = "https://datatracker.ietf.org/doc/draft-sibiryakov-ztds-protocol/"
+
+[project.optional-dependencies]
+fastapi = ["fastapi>=0.100.0", "uvicorn>=0.20.0", "pydantic>=2.0.0"]
+langchain = ["langchain-core>=0.1.0"]
+llamaindex = ["llama-index-core>=0.10.0"]
+all = [
+    "fastapi>=0.100.0",
+    "uvicorn>=0.20.0",
+    "pydantic>=2.0.0",
+    "langchain-core>=0.1.0",
+    "llama-index-core>=0.10.0"
+]
+
+[project.scripts]
+privacyscrubber = "privacyscrubber.cli:main"
+ps-bridge = "privacyscrubber.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["privacyscrubber*"]
+
+[tool.setuptools.package-data]
+privacyscrubber = ["*.cjs", "bridge_daemon.cjs"]