GitHub - clay-good/policybind: PolicyBind is an AI Policy-as-Code platform that enables organizations to govern AI usage through a unified model registry, real-time token-based access control, and automated compliance reporting for frameworks like the EU AI Act and NIST AI RMF.

name: enterprise-ai-policy
version: "1.0.0"

rules:
  - name: block-pii-external
    description: PII data cannot go to external providers
    match:
      and:
        - provider: { not_in: [internal, on-premise] }
        - data_classification: { contains: pii }
    action: DENY
    priority: 800

  - name: allow-engineering
    match:
      department: engineering
    action: ALLOW
    priority: 500

  - name: default-deny
    action: DENY
    priority: 0

from openai import OpenAI
from policybind.integrations.openai_integration import create_policy_client

# Create a policy-enforced OpenAI client
client = create_policy_client(
    policy_set=policy_set,
    user_id="user@example.com",
    department="engineering",
)

# Use normally - policies are automatically enforced
response = client.chat.completions.create(
    model="gpt-4",
    messages=[{"role": "user", "content": "Hello!"}]
)

from policybind.integrations.anthropic_integration import create_policy_client

client = create_policy_client(
    policy_set=policy_set,
    user_id="user@example.com",
    department="engineering",
)

response = client.messages.create(
    model="claude-3-opus-20240229",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Hello!"}]
)

from langchain_openai import ChatOpenAI
from policybind.integrations.langchain_integration import wrap_llm

# Wrap any LangChain LLM
llm = wrap_llm(
    llm=ChatOpenAI(model="gpt-4"),
    policy_set=policy_set,
    user_id="user@example.com",
)

# Use normally - policies automatically enforced
response = llm.invoke("Hello!")

# Register a deployment
policybind registry register \
  --name "customer-support-bot" \
  --provider openai \
  --model gpt-4 \
  --owner "support-team" \
  --data-categories "customer-data,pii"

# Assess risk
policybind registry risk-assess dep_abc123

# Approve for production
policybind registry approve dep_abc123 --ticket JIRA-456

# Create a token with natural language
policybind token create \
  --subject "marketing-analytics" \
  --permissions "Allow GPT-3.5 and Claude for content generation, \
                 max $50/day budget, no PII data"

# Or with explicit options
policybind token create \
  --subject "data-science-team" \
  --models "gpt-4,claude-3-*" \
  --budget 100 \
  --budget-period daily \
  --expires 30

# View incidents
policybind incident list --status open --severity high

# Generate incident report
policybind incident report inc_xyz789 --format pdf

# Compliance status report
policybind report compliance --framework eu-ai-act

# Export audit trail
policybind audit export --start 2024-01-01 --end 2024-01-31 --format json

git clone https://github.com/clay-good/policybind.git
cd policybind
pip install -e .

pip install policybind[server]

policybind --version
policybind --help

# Create a new project
mkdir my-ai-governance
cd my-ai-governance

# Initialize PolicyBind
policybind init

# Check status
policybind status

name: my-first-policy
version: "1.0.0"
description: Basic AI governance policy

rules:
  - name: allow-approved-models
    description: Allow access to approved models
    match:
      model:
        in:
          - gpt-4
          - gpt-3.5-turbo
          - claude-3-sonnet
    action: ALLOW
    priority: 100

  - name: default-deny
    description: Deny all other requests
    action: DENY
    priority: 0

policybind policy load policies/main.yaml
policybind policy show

# Test a request that should be allowed
policybind policy test policies/main.yaml \
  --request '{"provider": "openai", "model": "gpt-4"}'

# Test a request that should be denied
policybind policy test policies/main.yaml \
  --request '{"provider": "openai", "model": "davinci"}'

from policybind.engine.parser import PolicyParser
from policybind.engine.pipeline import EnforcementPipeline
from policybind.models.request import AIRequest

# Load policy
parser = PolicyParser()
result = parser.parse_file("policies/main.yaml")
policy_set = result.policy_set

# Create pipeline
pipeline = EnforcementPipeline(policy_set)

# Enforce a request
request = AIRequest(
    provider="openai",
    model="gpt-4",
    user_id="user-123",
    department="engineering",
)

response = pipeline.process(request)

if response.is_allowed():
    print("Request allowed")
else:
    print(f"Request denied: {response.reason}")

# Clone the repository
git clone https://github.com/clay-good/policybind.git
cd policybind

# Create virtual environment
python3 -m venv .venv
source .venv/bin/activate

# Install development dependencies
pip install -e ".[dev]"

# Run all tests
pytest

# Run with coverage
pytest --cov=policybind

# Run specific test file
pytest tests/test_engine.py

# Run tests in parallel
pytest -n auto

# Run linter
ruff check policybind/

# Run type checker
mypy policybind/

# Format code
ruff format policybind/

┌─────────────────────────────────────────────────────────────┐
│                      Applications                           │
│  (OpenAI, Anthropic, Google, LangChain, etc.)              │
└────────────────────┬────────────────────────────────────────┘
                     │
    ┌────────────────┼────────────────┐
    │                │                │
    v                v                v
┌─────────────┐ ┌──────────────┐ ┌─────────┐
│ Python SDK  │ │  HTTP API    │ │   CLI   │
│ (wrappers)  │ │  (aiohttp)   │ │(argparse)│
└────────────┬┘ └──────────┬───┘ └────┬────┘
             │             │          │
             └─────────────┼──────────┘
                           v
                 ┌──────────────────────────┐
                 │   PolicyBind Core        │
                 │  (Enforcement Engine)    │
                 └──────┬───────────────────┘
                        │
        ┌───────┬───────┼───────┬────────┬──────────┐
        │       │       │       │        │          │
        v       v       v       v        v          v
    ┌──────┬────────┬──────┬────────┬────────┬──────────┐
    │Policy│ Model  │Token │Incident│ Audit  │ Reports  │
    │Engine│Registry│Manager│Manager│ Logger │Generator │
    └──────┴────────┴──────┴────────┴────────┴──────────┘
                        │
                        v
                 ┌──────────────────┐
                 │   SQLite DB      │
                 │   (WAL mode)     │
                 └──────────────────┘

policybind/
├── engine/          # Policy parsing, matching, and execution
├── integrations/    # SDK wrappers for AI providers
├── models/          # Data models (Policy, Request, Response)
├── server/          # HTTP API (aiohttp-based)
├── cli/             # Command-line interface
├── storage/         # SQLite database layer
├── registry/        # Model deployment registry
├── tokens/          # Access token management
├── incidents/       # Incident tracking and workflows
├── reports/         # Compliance and audit reports
└── config/          # Configuration management