Merge pull request #53 from dewitt4/52-add-api-package

docs/README.md

@@ -1328,4 +1328,187 @@ pytest tests/vectors/
 
 # Run specific test file
 pytest tests/vectors/test_embedding_validator.py
-```
+```
+
+# LLMGuardian API Documentation
+
+## Base URL
+`https://api.llmguardian.com/v1` # replace llmguardian.com with your domain
+
+## Authentication
+Bearer token required in Authorization header:
+```
+Authorization: Bearer <your_token>
+```
+
+## Endpoints
+
+### Security Scan
+`POST /scan`
+
+Scans content for security violations.
+
+**Request:**
+```json
+{
+  "content": "string",
+  "context": {
+    "source": "string",
+    "user_id": "string"
+  },
+  "security_level": "medium"
+}
+```
+
+**Response:**
+```json
+{
+  "is_safe": true,
+  "risk_level": "low",
+  "violations": [
+    {
+      "type": "string",
+      "description": "string",
+      "location": "string"
+    }
+  ],
+  "recommendations": [
+    "string"
+  ],
+  "metadata": {
+    "timestamp": "2024-01-01T00:00:00Z"
+  }
+}
+```
+
+### Privacy Check
+`POST /privacy/check`
+
+Checks content for privacy violations.
+
+**Request:**
+```json
+{
+  "content": "string",
+  "privacy_level": "confidential",
+  "context": {
+    "department": "string",
+    "data_type": "string"
+  }
+}
+```
+
+**Response:**
+```json
+{
+  "compliant": true,
+  "violations": [
+    {
+      "category": "PII",
+      "details": "string",
+      "severity": "high"
+    }
+  ],
+  "modified_content": "string",
+  "metadata": {
+    "timestamp": "2024-01-01T00:00:00Z"
+  }
+}
+```
+
+### Vector Scan
+`POST /vectors/scan`
+
+Scans vector embeddings for security issues.
+
+**Request:**
+```json
+{
+  "vectors": [
+    [0.1, 0.2, 0.3]
+  ],
+  "metadata": {
+    "model": "string",
+    "source": "string"
+  }
+}
+```
+
+**Response:**
+```json
+{
+  "is_safe": true,
+  "vulnerabilities": [
+    {
+      "type": "poisoning",
+      "severity": "high",
+      "affected_indices": [1, 2, 3]
+    }
+  ],
+  "recommendations": [
+    "string"
+  ]
+}
+```
+
+## Error Responses
+```json
+{
+  "detail": "Error message",
+  "error_code": "ERROR_CODE",
+  "timestamp": "2024-01-01T00:00:00Z"
+}
+```
+
+## Rate Limiting
+- 100 requests per minute per API key
+- 429 Too Many Requests response when exceeded
+
+## SDKs
+```python
+from llmguardian import Client
+
+client = Client("<api_key>")
+result = client.scan_content("text to scan")
+```
+
+## Examples
+```python
+# Security scan
+response = requests.post(
+    "https://api.llmguardian.com/v1/scan",  # replace llmguardian.com with your domain
+    headers={"Authorization": f"Bearer {token}"},
+    json={
+        "content": "sensitive text",
+        "security_level": "high"
+    }
+)
+
+# Privacy check with context
+response = requests.post(
+    "https://api.llmguardian.com/v1/privacy/check",
+    headers={"Authorization": f"Bearer {token}"},
+    json={
+        "content": "text with PII",
+        "privacy_level": "restricted",
+        "context": {"department": "HR"}
+    }
+)
+```
+
+## Webhook Events
+```json
+{
+  "event": "security_violation",
+  "data": {
+    "violation_type": "string",
+    "severity": "high",
+    "timestamp": "2024-01-01T00:00:00Z"
+  }
+}
+```
+
+## API Status
+Check status at: https://status.llmguardian.com # replace llmguardian.com with your domain
+
+Rate limits and API metrics available in dashboard.

src/llmguardian/api/README.md

@@ -1 +1,182 @@
-# API Integration 
+# LLMGuardian API Documentation
+
+## Base URL
+`https://api.llmguardian.com/v1` # replace llmguardian.com with your domain
+
+## Authentication
+Bearer token required in Authorization header:
+```
+Authorization: Bearer <your_token>
+```
+
+## Endpoints
+
+### Security Scan
+`POST /scan`
+
+Scans content for security violations.
+
+**Request:**
+```json
+{
+  "content": "string",
+  "context": {
+    "source": "string",
+    "user_id": "string"
+  },
+  "security_level": "medium"
+}
+```
+
+**Response:**
+```json
+{
+  "is_safe": true,
+  "risk_level": "low",
+  "violations": [
+    {
+      "type": "string",
+      "description": "string",
+      "location": "string"
+    }
+  ],
+  "recommendations": [
+    "string"
+  ],
+  "metadata": {
+    "timestamp": "2024-01-01T00:00:00Z"
+  }
+}
+```
+
+### Privacy Check
+`POST /privacy/check`
+
+Checks content for privacy violations.
+
+**Request:**
+```json
+{
+  "content": "string",
+  "privacy_level": "confidential",
+  "context": {
+    "department": "string",
+    "data_type": "string"
+  }
+}
+```
+
+**Response:**
+```json
+{
+  "compliant": true,
+  "violations": [
+    {
+      "category": "PII",
+      "details": "string",
+      "severity": "high"
+    }
+  ],
+  "modified_content": "string",
+  "metadata": {
+    "timestamp": "2024-01-01T00:00:00Z"
+  }
+}
+```
+
+### Vector Scan
+`POST /vectors/scan`
+
+Scans vector embeddings for security issues.
+
+**Request:**
+```json
+{
+  "vectors": [
+    [0.1, 0.2, 0.3]
+  ],
+  "metadata": {
+    "model": "string",
+    "source": "string"
+  }
+}
+```
+
+**Response:**
+```json
+{
+  "is_safe": true,
+  "vulnerabilities": [
+    {
+      "type": "poisoning",
+      "severity": "high",
+      "affected_indices": [1, 2, 3]
+    }
+  ],
+  "recommendations": [
+    "string"
+  ]
+}
+```
+
+## Error Responses
+```json
+{
+  "detail": "Error message",
+  "error_code": "ERROR_CODE",
+  "timestamp": "2024-01-01T00:00:00Z"
+}
+```
+
+## Rate Limiting
+- 100 requests per minute per API key
+- 429 Too Many Requests response when exceeded
+
+## SDKs
+```python
+from llmguardian import Client
+
+client = Client("<api_key>")
+result = client.scan_content("text to scan")
+```
+
+## Examples
+```python
+# Security scan
+response = requests.post(
+    "https://api.llmguardian.com/v1/scan",  # replace llmguardian.com with your domain
+    headers={"Authorization": f"Bearer {token}"},
+    json={
+        "content": "sensitive text",
+        "security_level": "high"
+    }
+)
+
+# Privacy check with context
+response = requests.post(
+    "https://api.llmguardian.com/v1/privacy/check",
+    headers={"Authorization": f"Bearer {token}"},
+    json={
+        "content": "text with PII",
+        "privacy_level": "restricted",
+        "context": {"department": "HR"}
+    }
+)
+```
+
+## Webhook Events
+```json
+{
+  "event": "security_violation",
+  "data": {
+    "violation_type": "string",
+    "severity": "high",
+    "timestamp": "2024-01-01T00:00:00Z"
+  }
+}
+```
+
+## API Status
+Check status at: https://status.llmguardian.com # replace llmguardian.com with your domain
+
+Rate limits and API metrics available in dashboard.

src/llmguardian/api/__init__.py

@@ -0,0 +1,4 @@
+# src/llmguardian/api/__init__.py
+from .routes import router
+from .models import SecurityRequest, SecurityResponse
+from .security import SecurityMiddleware

src/llmguardian/api/app.py

@@ -0,0 +1,25 @@
+# src/llmguardian/api/app.py
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from .routes import router
+from .security import SecurityMiddleware
+
+app = FastAPI(
+    title="LLMGuardian API",
+    description="Security API for LLM applications",
+    version="1.0.0"
+)
+
+# Security middleware
+app.add_middleware(SecurityMiddleware)
+
+# CORS
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+app.include_router(router, prefix="/api/v1")

src/llmguardian/api/models.py

@@ -0,0 +1,33 @@
+# src/llmguardian/api/models.py
+from pydantic import BaseModel
+from typing import List, Optional, Dict, Any
+from enum import Enum
+from datetime import datetime
+
+class SecurityLevel(str, Enum):
+    LOW = "low"
+    MEDIUM = "medium" 
+    HIGH = "high"
+    CRITICAL = "critical"
+
+class SecurityRequest(BaseModel):
+    content: str
+    context: Optional[Dict[str, Any]]
+    security_level: SecurityLevel = SecurityLevel.MEDIUM
+
+class SecurityResponse(BaseModel):
+    is_safe: bool
+    risk_level: SecurityLevel
+    violations: List[Dict[str, Any]] 
+    recommendations: List[str]
+    metadata: Dict[str, Any]
+    timestamp: datetime
+
+class PrivacyRequest(BaseModel):
+    content: str
+    privacy_level: str
+    context: Optional[Dict[str, Any]]
+
+class VectorRequest(BaseModel):
+    vectors: List[List[float]]
+    metadata: Optional[Dict[str, Any]]

src/llmguardian/api/routes.py

@@ -0,0 +1,52 @@
+# src/llmguardian/api/routes.py
+from fastapi import APIRouter, Depends, HTTPException
+from typing import List
+from .models import (
+    SecurityRequest, SecurityResponse,
+    PrivacyRequest, VectorRequest
+)
+from ..data.privacy_guard import PrivacyGuard
+from ..vectors.vector_scanner import VectorScanner
+from .security import verify_token
+
+router = APIRouter()
+
+@router.post("/scan", response_model=SecurityResponse)
+async def scan_content(
+    request: SecurityRequest,
+    token: str = Depends(verify_token)
+):
+    try:
+        privacy_guard = PrivacyGuard()
+        result = privacy_guard.check_privacy(request.content, request.context)
+        return SecurityResponse(**result.__dict__)
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+@router.post("/privacy/check")
+async def check_privacy(
+    request: PrivacyRequest,
+    token: str = Depends(verify_token)
+):
+    try:
+        privacy_guard = PrivacyGuard() 
+        result = privacy_guard.enforce_privacy(
+            request.content,
+            request.privacy_level,
+            request.context
+        )
+        return result
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+@router.post("/vectors/scan") 
+async def scan_vectors(
+    request: VectorRequest,
+    token: str = Depends(verify_token)
+):
+    try:
+        scanner = VectorScanner()
+        result = scanner.scan_vectors(request.vectors, request.metadata)
+        return result
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e))

src/llmguardian/api/security.py

@@ -0,0 +1,54 @@
+# src/llmguardian/api/security.py
+from fastapi import HTTPException, Security
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+import jwt
+from datetime import datetime, timedelta
+from typing import Optional
+
+security = HTTPBearer()
+
+class SecurityMiddleware:
+    def __init__(
+        self,
+        secret_key: str = "your-256-bit-secret",
+        algorithm: str = "HS256"
+    ):
+        self.secret_key = secret_key
+        self.algorithm = algorithm
+
+    async def create_token(
+        self, data: dict, expires_delta: Optional[timedelta] = None
+    ):
+        to_encode = data.copy()
+        if expires_delta:
+            expire = datetime.utcnow() + expires_delta
+        else:
+            expire = datetime.utcnow() + timedelta(minutes=15)
+        to_encode.update({"exp": expire})
+        return jwt.encode(
+            to_encode, self.secret_key, algorithm=self.algorithm
+        )
+
+    async def verify_token(
+        self,
+        credentials: HTTPAuthorizationCredentials = Security(security)
+    ):
+        try:
+            payload = jwt.decode(
+                credentials.credentials,
+                self.secret_key,
+                algorithms=[self.algorithm]
+            )
+            return payload
+        except jwt.ExpiredSignatureError:
+            raise HTTPException(
+                status_code=401,
+                detail="Token has expired"
+            )
+        except jwt.JWTError:
+            raise HTTPException(
+                status_code=401,
+                detail="Could not validate credentials"
+            )
+
+verify_token = SecurityMiddleware().verify_token