Add core implementation: API, registry, audit, Docker config, and quickstart guide

.env.example

@@ -0,0 +1,44 @@
+# Application
+ENVIRONMENT=development
+DEBUG=False
+
+# API
+API_HOST=0.0.0.0
+API_PORT=8000
+
+# Database
+DATABASE_URL=postgresql://bdr_user:bdr_pass@localhost:5432/bdr_agent_factory
+DATABASE_POOL_SIZE=10
+DATABASE_MAX_OVERFLOW=20
+
+# Redis
+REDIS_URL=redis://localhost:6379/0
+REDIS_TTL=3600
+
+# Security
+SECRET_KEY=your-secret-key-change-in-production
+ACCESS_TOKEN_EXPIRE_MINUTES=30
+REFRESH_TOKEN_EXPIRE_DAYS=7
+
+# Rate Limiting
+RATE_LIMIT_PER_MINUTE=60
+RATE_LIMIT_PER_HOUR=1000
+
+# Monitoring
+ENABLE_METRICS=True
+METRICS_PORT=9090
+LOG_LEVEL=INFO
+
+# Audit
+AUDIT_RETENTION_DAYS=2555
+ENABLE_AUDIT_TRAIL=True
+
+# ML Models
+MODEL_CACHE_DIR=./models
+MAX_BATCH_SIZE=32
+INFERENCE_TIMEOUT=30
+
+# Governance
+REQUIRE_EXPLAINABILITY=True
+REQUIRE_AUDIT_TRAIL=True
+COMPLIANCE_FRAMEWORKS=IFRS17,HIPAA,GDPR,AML

Dockerfile

@@ -0,0 +1,26 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    gcc \
+    postgresql-client \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements
+COPY pyproject.toml .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -e .[ml]
+
+# Copy application code
+COPY src/ ./src/
+COPY AI_CAPABILITY_DICTIONARY.yaml .
+COPY CAPABILITY_SYSTEM_MAP.yaml .
+
+# Expose port
+EXPOSE 8000
+
+# Run application
+CMD ["uvicorn", "bdr_agent_factory.main:app", "--host", "0.0.0.0", "--port", "8000"]

QUICKSTART.md

@@ -0,0 +1,213 @@
+# 🚀 BDR Agent Factory - Quick Start Guide
+
+## Prerequisites
+
+- Python 3.11+
+- Docker & Docker Compose (optional)
+- PostgreSQL 16+ (if not using Docker)
+- Redis 7+ (if not using Docker)
+
+## Installation
+
+### Option 1: Docker (Recommended)
+
+```bash
+# Clone the repository
+git clone https://huggingface.co/spaces/BDR-AI/BDR-Agent-Factory
+cd BDR-Agent-Factory
+
+# Start all services
+docker-compose up -d
+
+# Check logs
+docker-compose logs -f api
+```
+
+The API will be available at http://localhost:8000
+
+### Option 2: Local Development
+
+```bash
+# Clone the repository
+git clone https://huggingface.co/spaces/BDR-AI/BDR-Agent-Factory
+cd BDR-Agent-Factory
+
+# Create virtual environment
+python3 -m venv venv
+source venv/bin/activate  # On Windows: venv\\Scripts\\activate
+
+# Install dependencies
+pip install -e .[ml,dev]
+
+# Copy environment file
+cp .env.example .env
+# Edit .env with your configuration
+
+# Start PostgreSQL and Redis (if not using Docker)
+# Then run the application
+uvicorn bdr_agent_factory.main:app --reload
+```
+
+## Quick Test
+
+### 1. Health Check
+
+```bash
+curl http://localhost:8000/api/v1/health
+```
+
+Expected response:
+```json
+{
+  "status": "healthy",
+  "timestamp": "2026-01-03T00:00:00",
+  "service": "BDR Agent Factory"
+}
+```
+
+### 2. List Capabilities
+
+```bash
+curl http://localhost:8000/api/v1/capabilities
+```
+
+### 3. Get Specific Capability
+
+```bash
+curl http://localhost:8000/api/v1/capabilities/cap_text_classification
+```
+
+### 4. Search Capabilities
+
+```bash
+curl http://localhost:8000/api/v1/capabilities/search/fraud
+```
+
+## API Documentation
+
+Once the server is running, visit:
+
+- **Swagger UI**: http://localhost:8000/docs
+- **ReDoc**: http://localhost:8000/redoc
+
+## Project Structure
+
+```
+BDR-Agent-Factory/
+├── src/
+│   └── bdr_agent_factory/
+│       ├── api/              # API endpoints
+│       ├── capabilities/     # AI capability implementations
+│       ├── core/            # Core functionality
+│       ├── models/          # Data models
+│       ├── services/        # Business logic
+│       └── utils/           # Utilities
+├── docs/                    # Documentation
+├── examples/                # Example implementations
+├── tests/                   # Test suite
+├── AI_CAPABILITY_DICTIONARY.yaml
+├── CAPABILITY_SYSTEM_MAP.yaml
+├── pyproject.toml
+├── Dockerfile
+└── docker-compose.yml
+```
+
+## Development Workflow
+
+### Running Tests
+
+```bash
+# Run all tests
+pytest
+
+# Run with coverage
+pytest --cov=bdr_agent_factory --cov-report=html
+
+# Run specific test file
+pytest tests/test_registry.py
+```
+
+### Code Quality
+
+```bash
+# Format code
+black src/ tests/
+
+# Lint code
+ruff check src/ tests/
+
+# Type checking
+mypy src/
+
+# Security scan
+bandit -r src/
+```
+
+### Database Migrations
+
+```bash
+# Create migration
+alembic revision --autogenerate -m "description"
+
+# Apply migrations
+alembic upgrade head
+
+# Rollback
+alembic downgrade -1
+```
+
+## Next Steps
+
+1. **Read the Documentation**
+   - [API Specification](docs/API_SPECIFICATION.md)
+   - [Architecture](docs/ARCHITECTURE.md)
+   - [Security Framework](docs/SECURITY_FRAMEWORK.md)
+
+2. **Explore Examples**
+   - [Text Classification](examples/text_classification_example.py)
+   - [Fraud Detection](examples/fraud_detection_example.py)
+   - [Integration Example](examples/integration_example.py)
+
+3. **Deploy to Production**
+   - Review [Deployment Guide](docs/VERSION_CONTROL_STRATEGY.md)
+   - Configure monitoring and logging
+   - Set up CI/CD pipeline
+
+## Troubleshooting
+
+### Port Already in Use
+
+```bash
+# Change port in docker-compose.yml or .env
+API_PORT=8001
+```
+
+### Database Connection Error
+
+```bash
+# Check PostgreSQL is running
+docker-compose ps
+
+# Check database logs
+docker-compose logs db
+```
+
+### Redis Connection Error
+
+```bash
+# Check Redis is running
+docker-compose ps
+
+# Test Redis connection
+redis-cli ping
+```
+
+## Support
+
+- **Documentation**: See `/docs` directory
+- **Issues**: Open an issue on HuggingFace
+- **Discussions**: Join the discussion board
+
+## License
+
+MIT License - See [LICENSE](LICENSE) for details

create_implementation.py

@@ -0,0 +1,300 @@
+#!/usr/bin/env python3
+"""Script to create all core implementation files for BDR Agent Factory."""
+
+import os
+from pathlib import Path
+
+# Core configuration file
+CONFIG_PY = '''"""Configuration management for BDR Agent Factory."""
+
+from typing import Optional
+from pydantic_settings import BaseSettings
+from pydantic import Field
+
+class Settings(BaseSettings):
+    """Application settings."""
+    
+    # Application
+    app_name: str = "BDR Agent Factory"
+    app_version: str = "0.1.0"
+    environment: str = Field(default="development", env="ENVIRONMENT")
+    debug: bool = Field(default=False, env="DEBUG")
+    
+    # API
+    api_host: str = Field(default="0.0.0.0", env="API_HOST")
+    api_port: int = Field(default=8000, env="API_PORT")
+    api_prefix: str = "/api/v1"
+    
+    # Database
+    database_url: str = Field(
+        default="postgresql://bdr_user:bdr_pass@localhost:5432/bdr_agent_factory",
+        env="DATABASE_URL"
+    )
+    
+    # Redis
+    redis_url: str = Field(default="redis://localhost:6379/0", env="REDIS_URL")
+    redis_ttl: int = Field(default=3600, env="REDIS_TTL")
+    
+    # Security
+    secret_key: str = Field(default="change-in-production", env="SECRET_KEY")
+    algorithm: str = "HS256"
+    access_token_expire_minutes: int = 30
+    
+    # Governance
+    require_explainability: bool = True
+    require_audit_trail: bool = True
+    audit_retention_days: int = 2555  # 7 years
+    
+    class Config:
+        env_file = ".env"
+        case_sensitive = False
+
+settings = Settings()
+'''
+
+# Capability Registry
+REGISTRY_PY = '''"""Capability Registry for managing AI capabilities."""
+
+from typing import Dict, List, Optional
+from datetime import datetime
+import yaml
+
+class CapabilityRegistry:
+    """Central registry for AI capabilities."""
+    
+    def __init__(self, capability_dict_path: str = "AI_CAPABILITY_DICTIONARY.yaml"):
+        self.capability_dict_path = capability_dict_path
+        self.capabilities: Dict[str, dict] = {}
+        self.load_capabilities()
+    
+    def load_capabilities(self):
+        """Load capabilities from YAML file."""
+        try:
+            with open(self.capability_dict_path, 'r') as f:
+                data = yaml.safe_load(f)
+                if 'capabilities' in data:
+                    for cap in data['capabilities']:
+                        self.capabilities[cap['id']] = cap
+        except FileNotFoundError:
+            print(f"Warning: {self.capability_dict_path} not found")
+    
+    def get_capability(self, capability_id: str) -> Optional[dict]:
+        """Get capability by ID."""
+        return self.capabilities.get(capability_id)
+    
+    def list_capabilities(self, category: Optional[str] = None) -> List[dict]:
+        """List all capabilities, optionally filtered by category."""
+        if category:
+            return [c for c in self.capabilities.values() if c.get('category') == category]
+        return list(self.capabilities.values())
+    
+    def search_capabilities(self, query: str) -> List[dict]:
+        """Search capabilities by name or description."""
+        query_lower = query.lower()
+        return [
+            c for c in self.capabilities.values()
+            if query_lower in c.get('name', '').lower() 
+            or query_lower in c.get('description', '').lower()
+        ]
+'''
+
+# Audit Logger
+AUDIT_PY = '''"""Audit logging for compliance and governance."""
+
+from typing import Any, Dict, Optional
+from datetime import datetime
+import json
+import hashlib
+
+class AuditLogger:
+    """Audit trail logger for AI operations."""
+    
+    def __init__(self, storage_backend: str = "database"):
+        self.storage_backend = storage_backend
+        self.audit_records = []
+    
+    def log_request(
+        self,
+        capability_id: str,
+        user_id: str,
+        input_data: Any,
+        metadata: Optional[Dict] = None
+    ) -> str:
+        """Log an AI capability request."""
+        audit_id = self._generate_audit_id()
+        
+        record = {
+            "audit_id": audit_id,
+            "timestamp": datetime.utcnow().isoformat(),
+            "capability_id": capability_id,
+            "user_id": user_id,
+            "input_hash": self._hash_data(input_data),
+            "metadata": metadata or {},
+            "event_type": "request"
+        }
+        
+        self._store_record(record)
+        return audit_id
+    
+    def log_response(
+        self,
+        audit_id: str,
+        output_data: Any,
+        explainability: Optional[Dict] = None,
+        decision_type: Optional[str] = None
+    ):
+        """Log an AI capability response."""
+        record = {
+            "audit_id": audit_id,
+            "timestamp": datetime.utcnow().isoformat(),
+            "output_hash": self._hash_data(output_data),
+            "explainability": explainability,
+            "decision_type": decision_type,
+            "event_type": "response"
+        }
+        
+        self._store_record(record)
+    
+    def _generate_audit_id(self) -> str:
+        """Generate unique audit ID."""
+        timestamp = datetime.utcnow().isoformat()
+        return hashlib.sha256(timestamp.encode()).hexdigest()[:16]
+    
+    def _hash_data(self, data: Any) -> str:
+        """Hash data for audit trail."""
+        data_str = json.dumps(data, sort_keys=True, default=str)
+        return hashlib.sha256(data_str.encode()).hexdigest()
+    
+    def _store_record(self, record: Dict):
+        """Store audit record."""
+        self.audit_records.append(record)
+        # In production, this would write to database
+'''
+
+# Main API application
+MAIN_PY = '''"""Main FastAPI application."""
+
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from .core.config import settings
+from .core.registry import CapabilityRegistry
+from .api import capabilities, health
+
+app = FastAPI(
+    title=settings.app_name,
+    version=settings.app_version,
+    description="Enterprise AI Governance Framework for Insurance"
+)
+
+# CORS
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Initialize registry
+registry = CapabilityRegistry()
+
+# Include routers
+app.include_router(health.router, prefix=settings.api_prefix, tags=["health"])
+app.include_router(capabilities.router, prefix=settings.api_prefix, tags=["capabilities"])
+
+@app.on_event("startup")
+async def startup_event():
+    """Startup tasks."""
+    print(f"Starting {settings.app_name} v{settings.app_version}")
+    print(f"Loaded {len(registry.capabilities)} capabilities")
+
+@app.on_event("shutdown")
+async def shutdown_event():
+    """Shutdown tasks."""
+    print("Shutting down BDR Agent Factory")
+'''
+
+# Health check endpoints
+HEALTH_PY = '''"""Health check endpoints."""
+
+from fastapi import APIRouter
+from datetime import datetime
+
+router = APIRouter()
+
+@router.get("/health")
+async def health_check():
+    """Health check endpoint."""
+    return {
+        "status": "healthy",
+        "timestamp": datetime.utcnow().isoformat(),
+        "service": "BDR Agent Factory"
+    }
+
+@router.get("/ready")
+async def readiness_check():
+    """Readiness check endpoint."""
+    return {
+        "status": "ready",
+        "timestamp": datetime.utcnow().isoformat()
+    }
+'''
+
+# Capabilities API endpoints
+CAPABILITIES_API_PY = '''"""Capabilities API endpoints."""
+
+from fastapi import APIRouter, HTTPException
+from typing import Optional, List
+from ..core.registry import CapabilityRegistry
+from ..core.audit import AuditLogger
+
+router = APIRouter()
+registry = CapabilityRegistry()
+audit_logger = AuditLogger()
+
+@router.get("/capabilities")
+async def list_capabilities(category: Optional[str] = None):
+    """List all capabilities."""
+    capabilities = registry.list_capabilities(category=category)
+    return {
+        "count": len(capabilities),
+        "capabilities": capabilities
+    }
+
+@router.get("/capabilities/{capability_id}")
+async def get_capability(capability_id: str):
+    """Get capability by ID."""
+    capability = registry.get_capability(capability_id)
+    if not capability:
+        raise HTTPException(status_code=404, detail="Capability not found")
+    return capability
+
+@router.get("/capabilities/search/{query}")
+async def search_capabilities(query: str):
+    """Search capabilities."""
+    results = registry.search_capabilities(query)
+    return {
+        "query": query,
+        "count": len(results),
+        "results": results
+    }
+'''
+
+# Create all files
+files_to_create = {
+    "src/bdr_agent_factory/core/config.py": CONFIG_PY,
+    "src/bdr_agent_factory/core/registry.py": REGISTRY_PY,
+    "src/bdr_agent_factory/core/audit.py": AUDIT_PY,
+    "src/bdr_agent_factory/main.py": MAIN_PY,
+    "src/bdr_agent_factory/api/health.py": HEALTH_PY,
+    "src/bdr_agent_factory/api/capabilities.py": CAPABILITIES_API_PY,
+}
+
+print("Creating implementation files...")
+for filepath, content in files_to_create.items():
+    Path(filepath).parent.mkdir(parents=True, exist_ok=True)
+    with open(filepath, 'w') as f:
+        f.write(content)
+    print(f"✓ Created {filepath}")
+
+print("\n✅ All core implementation files created successfully!")

docker-compose.yml

@@ -0,0 +1,39 @@
+version: '3.8'
+
+services:
+  api:
+    build: .
+    ports:
+      - "8000:8000"
+    environment:
+      - DATABASE_URL=postgresql://bdr_user:bdr_pass@db:5432/bdr_agent_factory
+      - REDIS_URL=redis://redis:6379/0
+      - ENVIRONMENT=development
+    depends_on:
+      - db
+      - redis
+    volumes:
+      - ./src:/app/src
+      - ./models:/app/models
+
+  db:
+    image: postgres:16-alpine
+    environment:
+      - POSTGRES_USER=bdr_user
+      - POSTGRES_PASSWORD=bdr_pass
+      - POSTGRES_DB=bdr_agent_factory
+    ports:
+      - "5432:5432"
+    volumes:
+      - postgres_data:/var/lib/postgresql/data
+
+  redis:
+    image: redis:7-alpine
+    ports:
+      - "6379:6379"
+    volumes:
+      - redis_data:/data
+
+volumes:
+  postgres_data:
+  redis_data:

pyproject.toml

@@ -0,0 +1,93 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "bdr-agent-factory"
+version = "0.1.0"
+description = "Enterprise AI Governance Framework for Insurance"
+readme = "README.md"
+requires-python = ">=3.11"
+license = {text = "MIT"}
+authors = [{name = "BDR AI Team"}]
+
+dependencies = [
+    "fastapi>=0.104.0",
+    "uvicorn[standard]>=0.24.0",
+    "pydantic>=2.5.0",
+    "pydantic-settings>=2.1.0",
+    "sqlalchemy>=2.0.0",
+    "alembic>=1.12.0",
+    "psycopg2-binary>=2.9.9",
+    "redis>=5.0.0",
+    "pyyaml>=6.0.1",
+    "python-jose[cryptography]>=3.3.0",
+    "passlib[bcrypt]>=1.7.4",
+    "python-multipart>=0.0.6",
+    "httpx>=0.25.0",
+]
+
+[project.optional-dependencies]
+ml = [
+    "transformers>=4.35.0",
+    "torch>=2.1.0",
+    "scikit-learn>=1.3.0",
+    "shap>=0.43.0",
+    "numpy>=1.24.0",
+    "pandas>=2.1.0",
+]
+
+dev = [
+    "pytest>=7.4.0",
+    "pytest-asyncio>=0.21.0",
+    "pytest-cov>=4.1.0",
+    "black>=23.11.0",
+    "ruff>=0.1.6",
+    "mypy>=1.7.0",
+    "pre-commit>=3.5.0",
+]
+
+test = [
+    "pytest>=7.4.0",
+    "pytest-asyncio>=0.21.0",
+    "pytest-cov>=4.1.0",
+    "httpx>=0.25.0",
+    "faker>=20.1.0",
+]
+
+security = [
+    "bandit>=1.7.5",
+    "safety>=2.3.5",
+    "pip-audit>=2.6.1",
+]
+
+all = [
+    "bdr-agent-factory[ml,dev,test,security]",
+]
+
+[project.scripts]
+bdr-factory = "bdr_agent_factory.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.black]
+line-length = 88
+target-version = ["py311"]
+
+[tool.ruff]
+line-length = 88
+target-version = "py311"
+
+[tool.mypy]
+python_version = "3.11"
+strict = true
+warn_return_any = true
+warn_unused_configs = true
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+python_files = ["test_*.py"]
+python_classes = ["Test*"]
+python_functions = ["test_*"]
+addopts = "--cov=bdr_agent_factory --cov-report=html --cov-report=term"

requirements.txt

@@ -0,0 +1,22 @@
+# Core dependencies
+fastapi>=0.104.0
+uvicorn[standard]>=0.24.0
+pydantic>=2.5.0
+pydantic-settings>=2.1.0
+sqlalchemy>=2.0.0
+alembic>=1.12.0
+psycopg2-binary>=2.9.9
+redis>=5.0.0
+pyyaml>=6.0.1
+python-jose[cryptography]>=3.3.0
+passlib[bcrypt]>=1.7.4
+python-multipart>=0.0.6
+httpx>=0.25.0
+
+# ML dependencies (optional)
+transformers>=4.35.0
+torch>=2.1.0
+scikit-learn>=1.3.0
+shap>=0.43.0
+numpy>=1.24.0
+pandas>=2.1.0

src/bdr_agent_factory/__init__.py

@@ -0,0 +1,14 @@
+"""BDR Agent Factory - Enterprise AI Governance Framework."""
+
+__version__ = "0.1.0"
+__author__ = "BDR AI Team"
+__description__ = "Single Source of Truth for Governed AI Capabilities in Insurance"
+
+from .core.config import settings
+from .core.registry import CapabilityRegistry
+
+__all__ = [
+    "settings",
+    "CapabilityRegistry",
+    "__version__",
+]

src/bdr_agent_factory/api/__init__.py

@@ -0,0 +1 @@
+"""Api module for BDR Agent Factory."""

src/bdr_agent_factory/api/capabilities.py

@@ -0,0 +1,37 @@
+"""Capabilities API endpoints."""
+
+from fastapi import APIRouter, HTTPException
+from typing import Optional, List
+from ..core.registry import CapabilityRegistry
+from ..core.audit import AuditLogger
+
+router = APIRouter()
+registry = CapabilityRegistry()
+audit_logger = AuditLogger()
+
+@router.get("/capabilities")
+async def list_capabilities(category: Optional[str] = None):
+    """List all capabilities."""
+    capabilities = registry.list_capabilities(category=category)
+    return {
+        "count": len(capabilities),
+        "capabilities": capabilities
+    }
+
+@router.get("/capabilities/{capability_id}")
+async def get_capability(capability_id: str):
+    """Get capability by ID."""
+    capability = registry.get_capability(capability_id)
+    if not capability:
+        raise HTTPException(status_code=404, detail="Capability not found")
+    return capability
+
+@router.get("/capabilities/search/{query}")
+async def search_capabilities(query: str):
+    """Search capabilities."""
+    results = registry.search_capabilities(query)
+    return {
+        "query": query,
+        "count": len(results),
+        "results": results
+    }

src/bdr_agent_factory/api/health.py

@@ -0,0 +1,23 @@
+"""Health check endpoints."""
+
+from fastapi import APIRouter
+from datetime import datetime
+
+router = APIRouter()
+
+@router.get("/health")
+async def health_check():
+    """Health check endpoint."""
+    return {
+        "status": "healthy",
+        "timestamp": datetime.utcnow().isoformat(),
+        "service": "BDR Agent Factory"
+    }
+
+@router.get("/ready")
+async def readiness_check():
+    """Readiness check endpoint."""
+    return {
+        "status": "ready",
+        "timestamp": datetime.utcnow().isoformat()
+    }

src/bdr_agent_factory/capabilities/__init__.py

@@ -0,0 +1 @@
+"""Capabilities module for BDR Agent Factory."""

src/bdr_agent_factory/core/__init__.py

@@ -0,0 +1 @@
+"""Core module for BDR Agent Factory."""

src/bdr_agent_factory/core/audit.py

@@ -0,0 +1,70 @@
+"""Audit logging for compliance and governance."""
+
+from typing import Any, Dict, Optional
+from datetime import datetime
+import json
+import hashlib
+
+class AuditLogger:
+    """Audit trail logger for AI operations."""
+    
+    def __init__(self, storage_backend: str = "database"):
+        self.storage_backend = storage_backend
+        self.audit_records = []
+    
+    def log_request(
+        self,
+        capability_id: str,
+        user_id: str,
+        input_data: Any,
+        metadata: Optional[Dict] = None
+    ) -> str:
+        """Log an AI capability request."""
+        audit_id = self._generate_audit_id()
+        
+        record = {
+            "audit_id": audit_id,
+            "timestamp": datetime.utcnow().isoformat(),
+            "capability_id": capability_id,
+            "user_id": user_id,
+            "input_hash": self._hash_data(input_data),
+            "metadata": metadata or {},
+            "event_type": "request"
+        }
+        
+        self._store_record(record)
+        return audit_id
+    
+    def log_response(
+        self,
+        audit_id: str,
+        output_data: Any,
+        explainability: Optional[Dict] = None,
+        decision_type: Optional[str] = None
+    ):
+        """Log an AI capability response."""
+        record = {
+            "audit_id": audit_id,
+            "timestamp": datetime.utcnow().isoformat(),
+            "output_hash": self._hash_data(output_data),
+            "explainability": explainability,
+            "decision_type": decision_type,
+            "event_type": "response"
+        }
+        
+        self._store_record(record)
+    
+    def _generate_audit_id(self) -> str:
+        """Generate unique audit ID."""
+        timestamp = datetime.utcnow().isoformat()
+        return hashlib.sha256(timestamp.encode()).hexdigest()[:16]
+    
+    def _hash_data(self, data: Any) -> str:
+        """Hash data for audit trail."""
+        data_str = json.dumps(data, sort_keys=True, default=str)
+        return hashlib.sha256(data_str.encode()).hexdigest()
+    
+    def _store_record(self, record: Dict):
+        """Store audit record."""
+        self.audit_records.append(record)
+        # In production, this would write to database

src/bdr_agent_factory/core/config.py

@@ -0,0 +1,45 @@
+"""Configuration management for BDR Agent Factory."""
+
+from typing import Optional
+from pydantic_settings import BaseSettings
+from pydantic import Field
+
+class Settings(BaseSettings):
+    """Application settings."""
+    
+    # Application
+    app_name: str = "BDR Agent Factory"
+    app_version: str = "0.1.0"
+    environment: str = Field(default="development", env="ENVIRONMENT")
+    debug: bool = Field(default=False, env="DEBUG")
+    
+    # API
+    api_host: str = Field(default="0.0.0.0", env="API_HOST")
+    api_port: int = Field(default=8000, env="API_PORT")
+    api_prefix: str = "/api/v1"
+    
+    # Database
+    database_url: str = Field(
+        default="postgresql://bdr_user:bdr_pass@localhost:5432/bdr_agent_factory",
+        env="DATABASE_URL"
+    )
+    
+    # Redis
+    redis_url: str = Field(default="redis://localhost:6379/0", env="REDIS_URL")
+    redis_ttl: int = Field(default=3600, env="REDIS_TTL")
+    
+    # Security
+    secret_key: str = Field(default="change-in-production", env="SECRET_KEY")
+    algorithm: str = "HS256"
+    access_token_expire_minutes: int = 30
+    
+    # Governance
+    require_explainability: bool = True
+    require_audit_trail: bool = True
+    audit_retention_days: int = 2555  # 7 years
+    
+    class Config:
+        env_file = ".env"
+        case_sensitive = False
+
+settings = Settings()

src/bdr_agent_factory/core/registry.py

@@ -0,0 +1,43 @@
+"""Capability Registry for managing AI capabilities."""
+
+from typing import Dict, List, Optional
+from datetime import datetime
+import yaml
+
+class CapabilityRegistry:
+    """Central registry for AI capabilities."""
+    
+    def __init__(self, capability_dict_path: str = "AI_CAPABILITY_DICTIONARY.yaml"):
+        self.capability_dict_path = capability_dict_path
+        self.capabilities: Dict[str, dict] = {}
+        self.load_capabilities()
+    
+    def load_capabilities(self):
+        """Load capabilities from YAML file."""
+        try:
+            with open(self.capability_dict_path, 'r') as f:
+                data = yaml.safe_load(f)
+                if 'capabilities' in data:
+                    for cap in data['capabilities']:
+                        self.capabilities[cap['id']] = cap
+        except FileNotFoundError:
+            print(f"Warning: {self.capability_dict_path} not found")
+    
+    def get_capability(self, capability_id: str) -> Optional[dict]:
+        """Get capability by ID."""
+        return self.capabilities.get(capability_id)
+    
+    def list_capabilities(self, category: Optional[str] = None) -> List[dict]:
+        """List all capabilities, optionally filtered by category."""
+        if category:
+            return [c for c in self.capabilities.values() if c.get('category') == category]
+        return list(self.capabilities.values())
+    
+    def search_capabilities(self, query: str) -> List[dict]:
+        """Search capabilities by name or description."""
+        query_lower = query.lower()
+        return [
+            c for c in self.capabilities.values()
+            if query_lower in c.get('name', '').lower() 
+            or query_lower in c.get('description', '').lower()
+        ]

src/bdr_agent_factory/main.py

@@ -0,0 +1,40 @@
+"""Main FastAPI application."""
+
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from .core.config import settings
+from .core.registry import CapabilityRegistry
+from .api import capabilities, health
+
+app = FastAPI(
+    title=settings.app_name,
+    version=settings.app_version,
+    description="Enterprise AI Governance Framework for Insurance"
+)
+
+# CORS
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Initialize registry
+registry = CapabilityRegistry()
+
+# Include routers
+app.include_router(health.router, prefix=settings.api_prefix, tags=["health"])
+app.include_router(capabilities.router, prefix=settings.api_prefix, tags=["capabilities"])
+
+@app.on_event("startup")
+async def startup_event():
+    """Startup tasks."""
+    print(f"Starting {settings.app_name} v{settings.app_version}")
+    print(f"Loaded {len(registry.capabilities)} capabilities")
+
+@app.on_event("shutdown")
+async def shutdown_event():
+    """Shutdown tasks."""
+    print("Shutting down BDR Agent Factory")

src/bdr_agent_factory/models/__init__.py

@@ -0,0 +1 @@
+"""Models module for BDR Agent Factory."""

src/bdr_agent_factory/services/__init__.py

@@ -0,0 +1 @@
+"""Services module for BDR Agent Factory."""

src/bdr_agent_factory/utils/__init__.py

@@ -0,0 +1 @@
+"""Utils module for BDR Agent Factory."""