"""
AI Model Configuration Templates
This module provides pre-configured setups for different AI model scenarios
with appropriate privacy and security settings.
"""
from typing import Dict, List
from .models import ModelConfig, ModelProvider, AIModelManager
from .data_privacy import DataMaskingConfig, PrivacyLevel, PRIVACY_CONFIGS
def create_secure_enterprise_setup() -> AIModelManager:
"""
Create AI manager with enterprise-grade security.
- Uses local models only (Ollama)
- Strict data privacy controls
- No external API calls
"""
manager = AIModelManager(PRIVACY_CONFIGS["high_security"])
# Register local models only
manager.register_model(
"llama2-secure",
ModelConfig(
provider=ModelProvider.LOCAL_OLLAMA,
model_name="llama2",
base_url="http://localhost:11434",
privacy_config=PRIVACY_CONFIGS["high_security"]
),
set_as_default=True
)
manager.register_model(
"codellama-secure",
ModelConfig(
provider=ModelProvider.LOCAL_OLLAMA,
model_name="codellama",
base_url="http://localhost:11434",
privacy_config=PRIVACY_CONFIGS["high_security"]
)
)
return manager
def create_development_setup() -> AIModelManager:
"""
Create AI manager for development environments.
- Includes both local and cloud models
- Moderate privacy controls
- Good for testing and development
"""
manager = AIModelManager(PRIVACY_CONFIGS["development"])
# Local models (preferred for development)
manager.register_model(
"llama2-dev",
ModelConfig(
provider=ModelProvider.LOCAL_OLLAMA,
model_name="llama2",
base_url="http://localhost:11434",
privacy_config=PRIVACY_CONFIGS["development"]
),
set_as_default=True
)
# Cloud models (require API keys)
try:
manager.register_model(
"claude-dev",
ModelConfig(
provider=ModelProvider.CLAUDE,
model_name="claude-3-haiku-20240307",
privacy_config=PRIVACY_CONFIGS["development"]
)
)
except ValueError:
pass # API key not available
try:
manager.register_model(
"gpt-dev",
ModelConfig(
provider=ModelProvider.OPENAI,
model_name="gpt-3.5-turbo",
privacy_config=PRIVACY_CONFIGS["development"]
)
)
except ValueError:
pass # API key not available
# Mock model for testing
manager.register_model(
"mock",
ModelConfig(
provider=ModelProvider.MOCK,
model_name="mock-model",
privacy_config=PRIVACY_CONFIGS["development"]
)
)
return manager
def create_cloud_optimized_setup() -> AIModelManager:
"""
Create AI manager optimized for cloud services.
- Prefers high-performance cloud models
- Balanced privacy settings
- Fallback to local models
"""
manager = AIModelManager(PRIVACY_CONFIGS["production"])
# Primary: Claude (best for complex reasoning)
try:
manager.register_model(
"claude-primary",
ModelConfig(
provider=ModelProvider.CLAUDE,
model_name="claude-3-sonnet-20240229",
privacy_config=PRIVACY_CONFIGS["production"]
),
set_as_default=True
)
except ValueError:
pass
# Secondary: GPT-4 (good alternative)
try:
manager.register_model(
"gpt4-secondary",
ModelConfig(
provider=ModelProvider.OPENAI,
model_name="gpt-4",
privacy_config=PRIVACY_CONFIGS["production"]
)
)
except ValueError:
pass
# Fallback: Local model
manager.register_model(
"local-fallback",
ModelConfig(
provider=ModelProvider.LOCAL_OLLAMA,
model_name="llama2",
base_url="http://localhost:11434",
privacy_config=PRIVACY_CONFIGS["production"]
)
)
# If no cloud models registered, use local as default
if not manager.default_model:
manager.default_model = "local-fallback"
return manager
def create_demo_setup() -> AIModelManager:
"""
Create AI manager for demonstrations.
- Uses mock models primarily
- Safe for public demos
- No real API calls
"""
manager = AIModelManager(PRIVACY_CONFIGS["demo"])
# Mock model for safe demonstrations
manager.register_model(
"demo-safe",
ModelConfig(
provider=ModelProvider.MOCK,
model_name="demo-model",
privacy_config=PRIVACY_CONFIGS["demo"]
),
set_as_default=True
)
# Local model as backup
manager.register_model(
"demo-local",
ModelConfig(
provider=ModelProvider.LOCAL_OLLAMA,
model_name="llama2",
base_url="http://localhost:11434",
privacy_config=PRIVACY_CONFIGS["demo"]
)
)
return manager
def create_custom_setup(config_dict: Dict) -> AIModelManager:
"""
Create AI manager from custom configuration dictionary.
Example config_dict:
{
"privacy_level": "strict",
"models": [
{
"name": "my-claude",
"provider": "claude",
"model_name": "claude-3-sonnet-20240229",
"api_key": "...",
"default": true
},
{
"name": "my-local",
"provider": "ollama",
"model_name": "llama2",
"base_url": "http://localhost:11434"
}
]
}
"""
privacy_level = config_dict.get("privacy_level", "moderate")
privacy_config = PRIVACY_CONFIGS.get(privacy_level, PRIVACY_CONFIGS["moderate"])
manager = AIModelManager(privacy_config)
for model_config in config_dict.get("models", []):
provider_str = model_config["provider"].lower()
provider_map = {
"claude": ModelProvider.CLAUDE,
"openai": ModelProvider.OPENAI,
"ollama": ModelProvider.LOCAL_OLLAMA,
"llamacpp": ModelProvider.LOCAL_LLAMACPP,
"mock": ModelProvider.MOCK
}
provider = provider_map.get(provider_str)
if not provider:
continue
config = ModelConfig(
provider=provider,
model_name=model_config["model_name"],
api_key=model_config.get("api_key"),
base_url=model_config.get("base_url"),
max_tokens=model_config.get("max_tokens", 4000),
temperature=model_config.get("temperature", 0.1),
privacy_config=privacy_config
)
try:
manager.register_model(
model_config["name"],
config,
set_as_default=model_config.get("default", False)
)
except Exception as e:
print(f"Warning: Failed to register model {model_config['name']}: {e}")
return manager
# Environment-based setup selector
def get_setup_for_environment(env: str = "development") -> AIModelManager:
"""
Get appropriate AI setup based on environment.
Args:
env: Environment name ("development", "production", "enterprise", "demo")
Returns:
Configured AIModelManager
"""
setup_map = {
"development": create_development_setup,
"dev": create_development_setup,
"production": create_cloud_optimized_setup,
"prod": create_cloud_optimized_setup,
"enterprise": create_secure_enterprise_setup,
"secure": create_secure_enterprise_setup,
"demo": create_demo_setup,
"test": create_demo_setup
}
setup_func = setup_map.get(env.lower(), create_development_setup)
return setup_func()
# Quick setup functions for common scenarios
def quick_local_setup() -> AIModelManager:
"""Quick setup with local models only."""
return create_secure_enterprise_setup()
def quick_cloud_setup() -> AIModelManager:
"""Quick setup with cloud models."""
return create_cloud_optimized_setup()
def quick_demo_setup() -> AIModelManager:
"""Quick setup for safe demonstrations."""
return create_demo_setup()
# Configuration validation
def validate_setup(manager: AIModelManager) -> Dict[str, List[str]]:
"""
Validate AI model manager setup and return status report.
Returns:
Dictionary with 'working', 'failed', and 'recommendations' lists
"""
working = []
failed = []
recommendations = []
for model_name in manager.list_models():
try:
model = manager.get_model(model_name)
# Simple test - this would be expanded for real validation
working.append(model_name)
except Exception as e:
failed.append(f"{model_name}: {str(e)}")
if not working:
recommendations.append("No working models found. Consider setting up local Ollama or providing API keys.")
if len(working) == 1:
recommendations.append("Only one model available. Consider adding backup models for reliability.")
return {
"working": working,
"failed": failed,
"recommendations": recommendations
}
