gateforge-sdk 0.1.0__py3-none-any.whl

gateforge/__init__.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+from gateforge.client import GatforgeClient
+from gateforge.response import GatforgeResponse
+
+_client: GatforgeClient | None = None
+
+
+def init(
+    api_key: str,
+    openai_key: str | None = None,
+    anthropic_key: str | None = None,
+    gemini_key: str | None = None,
+) -> None:
+    """
+    Initialize Gateforge. Downloads user config from api.gateforge.dev.
+    Call once at application startup.
+    """
+    global _client
+    _client = GatforgeClient(
+        api_key=api_key,
+        openai_key=openai_key,
+        anthropic_key=anthropic_key,
+        gemini_key=gemini_key,
+    )
+    _client.load_config()
+
+
+def chat(
+    model: str,
+    messages: list[dict],
+    provider_key: str | None = None,
+    pii_domain: str | None = None,
+    prompt_id: str | None = None,
+    **kwargs,
+) -> GatforgeResponse:
+    """LLM call with automatic PII masking. All processing is local."""
+    if _client is None:
+        raise RuntimeError("Call gateforge.init() first")
+    return _client.chat(
+        model=model,
+        messages=messages,
+        provider_key=provider_key,
+        pii_domain=pii_domain,
+        prompt_id=prompt_id,
+        **kwargs,
+    )
+
+
+def chat_stream(
+    model: str,
+    messages: list[dict],
+    **kwargs,
+):
+    """Streaming LLM call with automatic PII masking."""
+    if _client is None:
+        raise RuntimeError("Call gateforge.init() first")
+    return _client.chat_stream(model=model, messages=messages, **kwargs)

gateforge/client.py

@@ -0,0 +1,119 @@
+from __future__ import annotations
+
+import uuid
+
+from gateforge.config import fetch_config, GatforgeConfig
+from gateforge.pii import anonymize_messages, rehydrate_text
+from gateforge.metrics import send_metrics_async
+from gateforge.response import GatforgeResponse
+
+
+def _model_to_provider(model: str) -> str:
+    if model.startswith(("gpt-", "o1", "o3")):
+        return "openai"
+    if model.startswith("claude"):
+        return "anthropic"
+    if model.startswith("gemini"):
+        return "gemini"
+    raise ValueError(
+        f"Cannot infer provider from model name '{model}'. "
+        "Pass provider_key explicitly or use a model name starting with gpt-, claude, or gemini."
+    )
+
+
+class GatforgeClient:
+    def __init__(
+        self,
+        api_key: str,
+        openai_key: str | None = None,
+        anthropic_key: str | None = None,
+        gemini_key: str | None = None,
+    ):
+        self.api_key = api_key
+        self.provider_keys = {
+            "openai": openai_key,
+            "anthropic": anthropic_key,
+            "gemini": gemini_key,
+        }
+        self.config: GatforgeConfig = GatforgeConfig()
+
+    def load_config(self) -> None:
+        self.config = fetch_config(self.api_key)
+
+    def chat(
+        self,
+        model: str,
+        messages: list[dict],
+        provider_key: str | None = None,
+        pii_domain: str | None = None,
+        prompt_id: str | None = None,
+        **kwargs,
+    ) -> GatforgeResponse:
+        provider = _model_to_provider(model)
+        key = provider_key or self.provider_keys.get(provider)
+        if not key:
+            raise ValueError(
+                f"No {provider} key provided. Pass it to init() or as provider_key in chat()."
+            )
+
+        domain = pii_domain or self.config.pii_domain
+        backend = self.config.pii_backend
+
+        context = {
+            "tenant_id": self.api_key,
+            "case_id": prompt_id or "default",
+            "thread_id": str(uuid.uuid4()),
+            "actor_id": "sdk",
+        }
+
+        # 1. PII masking — local, never leaves the client
+        anon_messages, pii_entities = anonymize_messages(messages, domain, backend, context)
+
+        # 2. Direct LLM call
+        if provider == "openai":
+            from gateforge.providers.openai import call
+        elif provider == "anthropic":
+            from gateforge.providers.anthropic import call
+        else:
+            from gateforge.providers.gemini import call
+
+        content, meta = call(key, model, anon_messages, **kwargs)
+
+        # 3. Rehydration — local
+        final_content = rehydrate_text(content, domain, backend, context)
+
+        # 4. Async metrics — metadata only, never content
+        send_metrics_async(self.api_key, {
+            "model": meta["model"],
+            "provider": meta["provider"],
+            "prompt_tokens": meta["prompt_tokens"],
+            "completion_tokens": meta["completion_tokens"],
+            "cost_usd": meta["cost_usd"],
+            "latency_ms": meta["latency_ms"],
+            "pii_entities": pii_entities,
+            "pii_count": len(pii_entities),
+            "domain": domain,
+        })
+
+        return GatforgeResponse(
+            content=final_content,
+            model=meta["model"],
+            tokens=meta["total_tokens"],
+            prompt_tokens=meta["prompt_tokens"],
+            completion_tokens=meta["completion_tokens"],
+            cost_usd=meta["cost_usd"],
+            latency_ms=meta["latency_ms"],
+            pii_detected=pii_entities,
+            raw=meta.get("raw", {}),
+        )
+
+    def chat_stream(
+        self,
+        model: str,
+        messages: list[dict],
+        pii_domain: str | None = None,
+        prompt_id: str | None = None,
+        provider_key: str | None = None,
+        **kwargs,
+    ):
+        raise NotImplementedError("Streaming is not yet implemented in the SDK.")

gateforge/config.py

@@ -0,0 +1,38 @@
+import httpx
+from dataclasses import dataclass, field
+
+GATEFORGE_API = "https://api.gateforge.dev"
+
+
+@dataclass
+class GatforgeConfig:
+    pii_domain: str = "generic"
+    pii_backend: str = "presidio"
+    pii_languages: list[str] = field(default_factory=lambda: ["en"])
+    custom_rules: list[dict] = field(default_factory=list)
+    default_model: str = "gpt-4o"
+
+
+def fetch_config(api_key: str) -> GatforgeConfig:
+    """
+    Downloads user config from api.gateforge.dev.
+    Falls back to defaults silently if unreachable.
+    """
+    try:
+        resp = httpx.get(
+            f"{GATEFORGE_API}/sdk/config",
+            headers={"X-API-Key": api_key},
+            timeout=5.0,
+        )
+        if resp.status_code == 200:
+            data = resp.json()
+            return GatforgeConfig(
+                pii_domain=data.get("pii_domain", "generic"),
+                pii_backend=data.get("pii_backend", "presidio"),
+                pii_languages=data.get("pii_languages", ["en"]),
+                custom_rules=data.get("custom_rules", []),
+                default_model=data.get("default_model", "gpt-4o"),
+            )
+    except Exception:
+        pass
+    return GatforgeConfig()

gateforge/metrics.py

@@ -0,0 +1,25 @@
+import threading
+from datetime import datetime, timezone
+
+GATEFORGE_API = "https://api.gateforge.dev"
+
+
+def send_metrics_async(api_key: str, metrics: dict) -> None:
+    """
+    Sends metadata to api.gateforge.dev in a daemon thread.
+    Never sends content — only numeric metadata and entity category lists.
+    Never blocks or raises.
+    """
+    def _send():
+        try:
+            import httpx
+            httpx.post(
+                f"{GATEFORGE_API}/sdk/metrics",
+                json={**metrics, "ts": datetime.now(timezone.utc).isoformat()},
+                headers={"X-API-Key": api_key},
+                timeout=3.0,
+            )
+        except Exception:
+            pass
+
+    threading.Thread(target=_send, daemon=True).start()

gateforge/pii.py

@@ -0,0 +1,46 @@
+from functools import lru_cache
+
+
+@lru_cache(maxsize=8)
+def _get_firewall(domain: str, backend: str):
+    from privacy_firewall import create_firewall
+    return create_firewall(domain, detector_backend=backend)
+
+
+def anonymize_messages(
+    messages: list[dict],
+    domain: str,
+    backend: str,
+    context: dict,
+) -> tuple[list[dict], list[str]]:
+    """
+    Anonymizes content of user messages locally.
+    Returns (anonymized_messages, deduplicated_entity_types).
+    Only role=user messages are processed; system/assistant pass through unchanged.
+    """
+    fw = _get_firewall(domain, backend)
+    anonymized = []
+    all_entities: list[str] = []
+
+    for msg in messages:
+        if msg.get("role") == "user" and isinstance(msg.get("content"), str):
+            result = fw.anonymize(text=msg["content"], context=context)
+            if result.trace and hasattr(result.trace, "detected_entities"):
+                for e in result.trace.detected_entities:
+                    entity_type = (
+                        e.get("entity_type") if isinstance(e, dict)
+                        else getattr(e, "entity_type", None)
+                    )
+                    if entity_type:
+                        all_entities.append(entity_type)
+            anonymized.append({**msg, "content": result.sanitized_text})
+        else:
+            anonymized.append(msg)
+
+    return anonymized, list(set(all_entities))
+
+
+def rehydrate_text(text: str, domain: str, backend: str, context: dict) -> str:
+    """Restores original PII values in LLM response text."""
+    fw = _get_firewall(domain, backend)
+    return fw.rehydrate(text=text, context=context)

gateforge/providers/anthropic.py

@@ -0,0 +1,59 @@
+import time
+
+PRICING = {
+    "claude-opus-4-8":          (0.015,   0.075),
+    "claude-opus-4-5":          (0.015,   0.075),
+    "claude-sonnet-4-6":        (0.003,   0.015),
+    "claude-sonnet-4-5":        (0.003,   0.015),
+    "claude-haiku-4-5":         (0.0008,  0.004),
+    "claude-haiku-4-5-20251001":(0.0008,  0.004),
+    "claude-3-5-sonnet-20241022":(0.003,  0.015),
+    "claude-3-5-haiku-20241022": (0.0008, 0.004),
+    "claude-3-opus-20240229":   (0.015,   0.075),
+}
+
+
+def call(
+    anthropic_key: str,
+    model: str,
+    messages: list[dict],
+    **kwargs,
+) -> tuple[str, dict]:
+    import anthropic
+
+    client = anthropic.Anthropic(api_key=anthropic_key)
+
+    # Anthropic requires max_tokens; default to 1024 if not provided
+    kwargs.setdefault("max_tokens", 1024)
+
+    t0 = time.perf_counter()
+    response = client.messages.create(
+        model=model,
+        messages=messages,
+        **kwargs,
+    )
+    latency_ms = round((time.perf_counter() - t0) * 1000, 1)
+
+    usage = response.usage
+    prompt_tokens = usage.input_tokens
+    completion_tokens = usage.output_tokens
+
+    input_price, output_price = PRICING.get(model, (0.003, 0.015))
+    cost = round(
+        (prompt_tokens / 1000 * input_price)
+        + (completion_tokens / 1000 * output_price),
+        6,
+    )
+
+    content = response.content[0].text if response.content else ""
+
+    return content, {
+        "model": model,
+        "provider": "anthropic",
+        "prompt_tokens": prompt_tokens,
+        "completion_tokens": completion_tokens,
+        "total_tokens": prompt_tokens + completion_tokens,
+        "cost_usd": cost,
+        "latency_ms": latency_ms,
+        "raw": response.model_dump(),
+    }

gateforge/providers/gemini.py

@@ -0,0 +1,70 @@
+import time
+
+PRICING = {
+    "gemini-2.5-pro":          (0.00125,  0.010),
+    "gemini-2.5-flash":        (0.000075, 0.0003),
+    "gemini-2.5-flash-lite":   (0.000018, 0.000072),
+    "gemini-2.0-flash":        (0.0001,   0.0004),
+    "gemini-2.0-flash-lite":   (0.000018, 0.000072),
+    "gemini-1.5-pro":          (0.00125,  0.005),
+    "gemini-1.5-flash":        (0.000075, 0.0003),
+    "gemini-1.5-flash-8b":     (0.0000375,0.00015),
+}
+
+
+def call(
+    gemini_key: str,
+    model: str,
+    messages: list[dict],
+    **kwargs,
+) -> tuple[str, dict]:
+    from google import genai
+
+    client = genai.Client(api_key=gemini_key)
+
+    # Convert OpenAI-style messages to Gemini contents
+    contents = _messages_to_contents(messages)
+
+    t0 = time.perf_counter()
+    response = client.models.generate_content(
+        model=model,
+        contents=contents,
+        **kwargs,
+    )
+    latency_ms = round((time.perf_counter() - t0) * 1000, 1)
+
+    usage = response.usage_metadata
+    prompt_tokens = usage.prompt_token_count or 0
+    completion_tokens = usage.candidates_token_count or 0
+
+    input_price, output_price = PRICING.get(model, (0.000075, 0.0003))
+    cost = round(
+        (prompt_tokens / 1000 * input_price)
+        + (completion_tokens / 1000 * output_price),
+        6,
+    )
+
+    content = response.text or ""
+
+    return content, {
+        "model": model,
+        "provider": "gemini",
+        "prompt_tokens": prompt_tokens,
+        "completion_tokens": completion_tokens,
+        "total_tokens": prompt_tokens + completion_tokens,
+        "cost_usd": cost,
+        "latency_ms": latency_ms,
+        "raw": {"text": content, "usage": {"prompt_token_count": prompt_tokens, "candidates_token_count": completion_tokens}},
+    }
+
+
+def _messages_to_contents(messages: list[dict]) -> list:
+    """Convert OpenAI chat messages format to Gemini contents list."""
+    contents = []
+    for msg in messages:
+        role = msg.get("role", "user")
+        text = msg.get("content", "")
+        # Gemini uses "user" and "model" roles
+        gemini_role = "model" if role == "assistant" else "user"
+        contents.append({"role": gemini_role, "parts": [{"text": text}]})
+    return contents

gateforge/providers/openai.py

@@ -0,0 +1,50 @@
+import time
+
+# Pricing: (input_per_1k, output_per_1k) in USD
+PRICING = {
+    "gpt-4o":        (0.005,    0.015),
+    "gpt-4o-mini":   (0.00015,  0.0006),
+    "gpt-4.1":       (0.002,    0.008),
+    "gpt-4.1-mini":  (0.0001,   0.0004),
+    "gpt-4.1-nano":  (0.00005,  0.0002),
+    "o1":            (0.015,    0.060),
+    "o1-mini":       (0.003,    0.012),
+    "o3-mini":       (0.0011,   0.0044),
+}
+
+
+def call(
+    openai_key: str,
+    model: str,
+    messages: list[dict],
+    **kwargs,
+) -> tuple[str, dict]:
+    from openai import OpenAI
+
+    client = OpenAI(api_key=openai_key)
+    t0 = time.perf_counter()
+    response = client.chat.completions.create(
+        model=model,
+        messages=messages,
+        **kwargs,
+    )
+    latency_ms = round((time.perf_counter() - t0) * 1000, 1)
+
+    usage = response.usage
+    input_price, output_price = PRICING.get(model, (0.005, 0.015))
+    cost = round(
+        (usage.prompt_tokens / 1000 * input_price)
+        + (usage.completion_tokens / 1000 * output_price),
+        6,
+    )
+
+    return response.choices[0].message.content, {
+        "model": model,
+        "provider": "openai",
+        "prompt_tokens": usage.prompt_tokens,
+        "completion_tokens": usage.completion_tokens,
+        "total_tokens": usage.total_tokens,
+        "cost_usd": cost,
+        "latency_ms": latency_ms,
+        "raw": response.model_dump(),
+    }

gateforge/response.py

@@ -0,0 +1,14 @@
+from dataclasses import dataclass, field
+
+
+@dataclass
+class GatforgeResponse:
+    content: str
+    model: str
+    tokens: int
+    prompt_tokens: int
+    completion_tokens: int
+    cost_usd: float
+    latency_ms: float
+    pii_detected: list[str]
+    raw: dict = field(default_factory=dict)

gateforge_sdk-0.1.0.dist-info/METADATA

@@ -0,0 +1,365 @@
+Metadata-Version: 2.4
+Name: gateforge-sdk
+Version: 0.1.0
+Summary: Privacy-first LLMOps SDK — Automatic PII masking, cost tracking, and prompt management for LLM applications
+Project-URL: Homepage, https://gateforge.dev
+Project-URL: Documentation, https://gateforge.dev/docs
+Project-URL: Repository, https://github.com/gateforge/gateforge-sdk
+Project-URL: Dashboard, https://app.gateforge.dev
+Project-URL: Bug Tracker, https://github.com/gateforge/gateforge-sdk/issues
+Author-email: Gateforge Team <support@gateforge.dev>
+License: MIT
+License-File: LICENSE
+Keywords: anthropic,gemini,llm,llmops,mlops,openai,pii,privacy
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Security
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: pii-firewall[langdetect,presidio]
+Provides-Extra: all
+Requires-Dist: anthropic>=0.40.0; extra == 'all'
+Requires-Dist: google-genai>=1.0.0; extra == 'all'
+Requires-Dist: openai>=1.0.0; extra == 'all'
+Provides-Extra: anthropic
+Requires-Dist: anthropic>=0.40.0; extra == 'anthropic'
+Provides-Extra: dev
+Requires-Dist: build>=1.0.0; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.23.0; extra == 'dev'
+Requires-Dist: pytest>=8.0.0; extra == 'dev'
+Requires-Dist: twine>=5.0.0; extra == 'dev'
+Provides-Extra: gemini
+Requires-Dist: google-genai>=1.0.0; extra == 'gemini'
+Provides-Extra: openai
+Requires-Dist: openai>=1.0.0; extra == 'openai'
+Description-Content-Type: text/markdown
+
+# Gateforge SDK
+
+**Privacy-first LLMOps SDK** — Automatic PII masking, cost tracking, and prompt management for LLM applications.
+
+[![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
+[![License](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+
+## 🔒 What is Gateforge?
+
+Gateforge is an LLMOps platform that automatically protects sensitive data (PII) in your LLM applications. The SDK processes everything **locally** — no content ever leaves your infrastructure.
+
+> **Note:** This SDK is free and open source (MIT license). It requires a Gateforge account to use. We offer a generous free tier: **1,000 requests/month**. See [pricing](https://gateforge.dev/pricing) for details.
+
+**Key Features:**
+- ✅ **Automatic PII Detection & Masking** — Names, emails, SSN, phone numbers, credit cards, and more
+- ✅ **Multi-Provider Support** — OpenAI, Anthropic, Gemini with unified interface
+- ✅ **Cost Tracking** — Real-time metrics and dashboards
+- ✅ **Domain-Specific Detection** — Healthcare, Finance, Legal, Generic
+- ✅ **Custom Regex Patterns** — Add your own entity types
+- ✅ **Zero Network Overhead** — All PII processing happens locally
+
+## 🚀 Quick Start
+
+### Installation
+
+```bash
+pip install gateforge-sdk
+```
+
+With provider support:
+```bash
+pip install gateforge-sdk[openai]      # OpenAI only
+pip install gateforge-sdk[anthropic]   # Anthropic only
+pip install gateforge-sdk[gemini]      # Google Gemini only
+pip install gateforge-sdk[all]         # All providers
+```
+
+### Get Your API Key
+
+1. Sign up at [https://gateforge.dev](https://gateforge.dev)
+2. Get your API key from [https://app.gateforge.dev/dashboard/keys](https://app.gateforge.dev/dashboard/keys)
+
+### Basic Usage
+
+```python
+import gateforge
+
+# Initialize once at startup
+gateforge.init(
+    api_key="your-gateforge-api-key",
+    openai_key="your-openai-key",
+)
+
+# Make LLM calls with automatic PII protection
+response = gateforge.chat(
+    model="gpt-4.1-nano",
+    messages=[
+        {"role": "user", "content": "My email is john@example.com, can you help?"}
+    ]
+)
+
+print(response.content)          # "Hello! I'd be happy to help..."
+print(response.pii_detected)     # ['EMAIL']
+print(response.tokens)           # 45
+print(response.cost_usd)         # 0.000023
+```
+
+## 📖 Examples
+
+### Healthcare Domain
+
+```python
+response = gateforge.chat(
+    model="gpt-4.1-nano",
+    messages=[
+        {
+            "role": "user",
+            "content": "Patient John Doe, SSN 123-45-6789, has hypertension. Recommend treatment."
+        }
+    ],
+    pii_domain="healthcare"  # Detects medical entities
+)
+
+print(response.pii_detected)  # ['PERSON', 'SSN', 'SYMPTOM']
+```
+
+### Multiple Providers
+
+```python
+import gateforge
+
+gateforge.init(
+    api_key="your-gateforge-key",
+    openai_key="sk-...",
+    anthropic_key="sk-ant-...",
+    gemini_key="...",
+)
+
+# OpenAI
+r1 = gateforge.chat(model="gpt-4.1-nano", messages=[...])
+
+# Anthropic
+r2 = gateforge.chat(model="claude-haiku-4-5", messages=[...])
+
+# Gemini
+r3 = gateforge.chat(model="gemini-2.5-flash", messages=[...])
+```
+
+### Custom PII Patterns
+
+Configure custom patterns in your dashboard at [https://app.gateforge.dev/dashboard/pii/settings](https://app.gateforge.dev/dashboard/pii/settings), and the SDK will download them automatically.
+
+## 🔧 Configuration
+
+### Initialization Options
+
+```python
+gateforge.init(
+    api_key="your-gateforge-api-key",    # Required
+    openai_key="sk-...",                  # Optional
+    anthropic_key="sk-ant-...",           # Optional
+    gemini_key="...",                     # Optional
+)
+```
+
+### Chat Parameters
+
+```python
+response = gateforge.chat(
+    model="gpt-4.1-nano",              # Required: model name
+    messages=[...],                     # Required: chat messages
+    pii_domain="generic",              # Optional: "generic", "healthcare", "finance", "legal"
+    provider_key="sk-...",             # Optional: override provider key
+    prompt_id="user-signup",           # Optional: for prompt tracking
+    temperature=0.7,                   # Optional: model parameters
+    max_tokens=500,                    # Optional: model parameters
+)
+```
+
+### Response Object
+
+```python
+response = gateforge.chat(...)
+
+response.content           # str: The response content
+response.pii_detected      # list[str]: Detected PII types
+response.tokens            # int: Total tokens
+response.prompt_tokens     # int: Input tokens
+response.completion_tokens # int: Output tokens
+response.cost_usd          # float: Cost in USD
+response.latency_ms        # float: Latency in milliseconds
+response.model             # str: Model used
+response.raw               # dict: Raw provider response
+```
+
+## 🔒 Privacy & Security
+
+### How it Works
+
+1. **Local Processing**: All PII detection happens locally in your environment
+2. **Content Never Sent**: Only metadata (tokens, cost) is sent to Gateforge API
+3. **Automatic Masking**: PII is replaced with tokens before sending to LLM providers
+4. **Automatic Rehydration**: Responses are reconstructed with original context
+
+### What Gets Detected?
+
+- **Personal**: Names, emails, phone numbers, addresses
+- **Financial**: Credit cards, bank accounts, SSN, tax IDs
+- **Healthcare**: Medical record numbers, symptoms, diagnoses
+- **Technical**: IP addresses, URLs, API keys
+- **Custom**: Your own regex patterns
+
+### Supported Backends
+
+- **Presidio** (default): ML-based, highest accuracy
+- **Regex**: Pattern matching, fastest
+- **Hybrid**: Combined ML + regex
+- **GLiNER**: Zero-shot NER
+- **Transformers**: HuggingFace models
+
+## 📊 Dashboard & Monitoring
+
+View real-time metrics at [https://app.gateforge.dev/dashboard](https://app.gateforge.dev/dashboard):
+
+- 📈 Request volume and trends
+- 💰 Cost breakdown by model and provider
+- ⚡ Latency analytics
+- 🔒 PII detection statistics
+- 🔑 API key management
+
+## 🛠️ Advanced Usage
+
+### Streaming (Coming Soon)
+
+```python
+for chunk in gateforge.chat_stream(model="gpt-4.1-nano", messages=[...]):
+    print(chunk.content, end="", flush=True)
+```
+
+### Async Support (Coming Soon)
+
+```python
+response = await gateforge.achat(model="gpt-4.1-nano", messages=[...])
+```
+
+### Direct Anonymization
+
+```python
+from gateforge.pii import anonymize_messages
+
+context = {
+    "tenant_id": "user-123",
+    "case_id": "case-456",
+    "thread_id": "thread-789",
+    "actor_id": "user"
+}
+
+anonymized, entities = anonymize_messages(
+    messages=[{"role": "user", "content": "My email is john@example.com"}],
+    domain="generic",
+    backend="presidio",
+    context=context
+)
+
+print(anonymized)  # [{"role": "user", "content": "My email is [EMAIL_001]"}]
+print(entities)    # ['EMAIL']
+```
+
+## 🌐 Supported Models
+
+### OpenAI
+- GPT-4.1-nano, GPT-4.1-mini, GPT-4.1, GPT-4.1-turbo
+- GPT-4o, GPT-4o-mini
+- GPT-3.5-turbo
+
+### Anthropic
+- Claude Haiku 4-5
+- Claude Sonnet 4-5
+- Claude Opus 4
+
+### Google Gemini
+- Gemini 2.5 Flash
+- Gemini 2.5 Pro
+
+## 📝 Configuration via Dashboard
+
+### PII Settings
+
+1. Go to [https://app.gateforge.dev/dashboard/pii/settings](https://app.gateforge.dev/dashboard/pii/settings)
+2. Select domain: Generic, Healthcare, Finance, Legal
+3. Choose backend: Presidio, Regex, Hybrid
+4. Set language: Auto-detect or specific language
+5. Add custom regex patterns
+
+The SDK downloads your configuration automatically on init.
+
+### Custom Patterns
+
+Add patterns like:
+```
+Entity Type: EMPLOYEE_ID
+Regex: EMP-\d{6}
+Confidence: 0.95
+```
+
+## 🐛 Troubleshooting
+
+### ImportError: No module named 'gateforge'
+
+```bash
+pip install gateforge-sdk
+```
+
+### RuntimeError: Call gateforge.init() first
+
+Make sure to initialize before making calls:
+```python
+gateforge.init(api_key="your-key")
+```
+
+### API Key Not Working
+
+1. Verify your key at [https://app.gateforge.dev/dashboard/keys](https://app.gateforge.dev/dashboard/keys)
+2. Check it's not revoked
+3. Ensure you're using the correct environment
+
+### PII Not Detected
+
+1. Check your domain setting matches your use case
+2. Try different backends (presidio is most accurate)
+3. Add custom patterns for domain-specific entities
+
+## 📚 Documentation
+
+- **Website**: [https://gateforge.dev](https://gateforge.dev)
+- **Dashboard**: [https://app.gateforge.dev](https://app.gateforge.dev)
+- **API Docs**: [https://api.gateforge.dev/docs](https://api.gateforge.dev/docs)
+
+## 🤝 Contributing
+
+Contributions are welcome! Please open an issue or submit a pull request.
+
+## 📄 License
+
+MIT License - See [LICENSE](LICENSE) for details.
+
+**Important:** While the SDK is open source, the Gateforge service is commercial. You need a Gateforge account (free tier available) to use this SDK.
+
+## 🔗 Links
+
+- [Website](https://gateforge.dev)
+- [Dashboard](https://app.gateforge.dev)
+- [API Health](https://api.gateforge.dev/v1/health)
+- [Documentation](https://gateforge.dev/docs)
+
+## 💬 Support
+
+- **Email**: support@gateforge.dev
+- **Issues**: [GitHub Issues](https://github.com/gateforge/gateforge-sdk/issues)
+
+---
+
+**Made with ❤️ by the Gateforge team**

gateforge_sdk-0.1.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+gateforge/__init__.py,sha256=jlIhvOjDeNBF6pq4-0So2hPir4AZXwB4DJD0SBdWXso,1480
+gateforge/client.py,sha256=tgSQjGDzVr7J6fUZoxQJbxFtfMBsEtd9FUbdR5Fkkno,3866
+gateforge/config.py,sha256=0She_mox_G8B3g0iBr4CdDCblMgfKEdnmur2bTb5fQo,1186
+gateforge/metrics.py,sha256=k3EdEBDqzRhE4i5KTWImvlMwfMWt0xV4Nem0I9gD-IE,744
+gateforge/pii.py,sha256=G4QHdweuWlOyLLEh5hfSv9Di29qK-VzNCO7OnbVMe1k,1651
+gateforge/response.py,sha256=XrBKaGlfPbVgpX_ozhHusK0bb8GRpCU29Z5gQ92eNCE,290
+gateforge/providers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gateforge/providers/anthropic.py,sha256=XpU6TXODaw3oGDPJaRuHYcEpEDqRAHkPHY3_sNZ8wVo,1695
+gateforge/providers/gemini.py,sha256=N1p6m0JJGXQos4Gu4WoYLJvoILgCjda2TkKFBBVMmrY,2197
+gateforge/providers/openai.py,sha256=cODmvE2lQRWwbFRXcTDEhP_e0vw3ZmCEZaJYW-KpYvo,1384
+gateforge_sdk-0.1.0.dist-info/METADATA,sha256=RxiZweYywfHyHHbwMMhb0he6yGhm4JP_5_xvhK1fw68,10885
+gateforge_sdk-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+gateforge_sdk-0.1.0.dist-info/licenses/LICENSE,sha256=1BtvvSjjJj2tVyp3LZfuNwrzoTkOcqm5O7n3jagI6uA,1629
+gateforge_sdk-0.1.0.dist-info/RECORD,,

gateforge_sdk-0.1.0.dist-info/WHEEL

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

gateforge_sdk-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,37 @@
+MIT License
+
+Copyright (c) 2026 Gateforge
+
+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.
+
+---
+
+IMPORTANT NOTICE:
+
+This SDK requires a Gateforge account and API key to function.
+Service usage is subject to Gateforge's Terms of Service and Privacy Policy:
+- Terms of Service: https://gateforge.dev/terms
+- Privacy Policy: https://gateforge.dev/privacy
+- Pricing: https://gateforge.dev/pricing
+
+The Gateforge service (api.gateforge.dev) is a commercial SaaS offering
+operated by Gateforge. Different pricing plans and usage limits apply.
+
+Free tier: 1,000 requests/month
+See https://gateforge.dev/pricing for details.