incident-responder

This project provides comprehensive scripts and references for 11 ML/AI-related skills, designed for production use with best practices, error handling, and configuration management.

```

claude-skills-conversion/

├── ai-engineer-skill/ # AI service integration, RAG, prompts

├── llm-architect-skill/ # LLM design, fine-tuning, serving

├── ml-engineer-skill/ # ML pipelines, scikit-learn

├── mlops-engineer-skill/ # MLflow, deployment, monitoring

├── machine-learning-engineer-skill/ # Jupyter, feature engineering

├── data-engineer-skill/ # ETL pipelines, data lakes

├── data-scientist-skill/ # Statistical analysis, visualization

├── data-analyst-skill/ # Data analysis, dashboards

├── prompt-engineer-skill/ # Prompt optimization, A/B testing

├── postgres-pro-skill/ # PostgreSQL administration

├── devops-incident-responder-skill/ # Incident response automation

└── incident-responder-skill/ # Alert handling and triage

```

1. AI Engineer

Scripts:

• integrate_openai.py - OpenAI API integration with retry logic
• integrate_anthropic.py - Claude API integration
• setup_rag.py - RAG system with vector database
• manage_prompts.py - Prompt template management
• monitor_ai_service.py - AI service health monitoring
• optimize_tokens.py - Token usage and cost tracking

References:

• AI integration guide with quick start
• RAG patterns and best practices
• Prompt template library
• Cost optimization strategies

Use Cases:

• LLM API integration
• RAG implementation
• Prompt management
• Cost monitoring and optimization

2. LLM Architect

Scripts:

• benchmark_models.py - Model comparison and selection
• finetune_model.py - Fine-tuning with LoRA/PEFT
• setup_rag_pipeline.py - End-to-end RAG pipeline
• serve_model.py - Model serving infrastructure
• engineer_prompts.py - Prompt optimization
• evaluate_model.py - Model evaluation framework

References:

• Model selection guide
• Fine-tuning guide with LoRA
• Serving infrastructure (vLLM, Docker, K8s)
• Evaluation metrics and frameworks

Use Cases:

• Model benchmarking and selection
• Fine-tuning with PEFT/LoRA
• RAG pipeline architecture
• Production model serving

3. ML Engineer

Scripts:

• train_sklearn.py - Scikit-learn training pipeline
• tune_hyperparameters.py - Optuna hyperparameter optimization

References:

• Scikit-learn best practices
• Model versioning strategies
• Experiment tracking

Use Cases:

• Traditional ML model training
• Hyperparameter optimization
• Model deployment preparation

4. MLOps Engineer

Scripts:

• track_mlflow.py - MLflow experiment tracking and model registry

Use Cases:

• Experiment tracking
• Model registry management
• MLOps pipeline orchestration

5. PostgreSQL Pro

Scripts:

• backup_pg.py - PostgreSQL backup and restore

Use Cases:

• Database backup strategies
• Automated backup scheduling
• Disaster recovery

6. Data Engineer

Scripts:

• run_etl_pipeline.py - ETL automation with scheduling

Use Cases:

• Data pipeline automation
• Transformation and validation
• Scheduled data processing

7. Incident Responder

Scripts:

• handle_alerts.py - Incident classification and triage

Use Cases:

• Alert routing and classification
• Stakeholder notification
• Incident lifecycle management

Prerequisites

```bash

# Python dependencies

pip install scikit-learn pandas numpy

pip install transformers peft datasets

pip install chromadb sentence-transformers

pip install mlflow optuna

pip install openai anthropic

pip install fastapi uvicorn

# Optional: GPU support

pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118

```

Environment Setup

```bash

# Set API keys

export OPENAI_API_KEY="your-openai-key"

export ANTHROPIC_API_KEY="your-anthropic-key"

# PostgreSQL

export PGPASSWORD="your-db-password"

```

AI Engineer - OpenAI Integration

```python

from ai_engineer_skill.scripts.integrate_openai import OpenAIIntegration, OpenAIConfig

config = OpenAIConfig(api_key=os.getenv("OPENAI_API_KEY"))

integration = OpenAIIntegration(config)

messages = [{"role": "user", "content": "Hello!"}]

response = integration.chat_completion(messages)

print(response['content'])

```

LLM Architect - Model Benchmarking

```python

from llm_architect_skill.scripts.benchmark_models import ModelBenchmarker

benchmarker = ModelBenchmarker(models)

benchmarker.benchmark_task("summarization", task_func, test_data)

best = benchmarker.get_best_model_for_task("summarization")

```

ML Engineer - Training Pipeline

```python

from ml_engineer_skill.scripts.train_sklearn import MLModelTrainer, ModelConfig

trainer = MLModelTrainer(ModelConfig())

X_train, X_test = trainer.preprocess_features(X_train, X_test)

trainer.train_model(X_train, y_train)

metrics = trainer.evaluate_model(X_test, y_test)

```

MLOps - MLflow Tracking

```python

from mlops_engineer_skill.scripts.track_mlflow import MLflowTracker

tracker = MLflowTracker(experiment_name="my_experiment")

run_id = tracker.start_run("run_1")

tracker.log_params({"lr": 0.01, "epochs": 10})

tracker.log_metrics({"accuracy": 0.95})

tracker.log_model(model, "my_model")

tracker.end_run()

```

Error Handling

All scripts include:

• Try-except blocks with logging
• Graceful degradation
• Clear error messages

Configuration

• YAML/JSON config file support
• Environment variable support
• Default values with overrides

Logging

• Structured logging
• Multiple log levels
• Timestamp and context

Documentation

• Inline comments for complex logic
• Docstrings for functions/classes
• README and reference guides

Each skill follows consistent patterns:

1. Create scripts/ directory for executable code
2. Create references/ directory for documentation
3. Use dataclasses for configuration
4. Include error handling and logging
5. Provide example usage in main() function

Production-ready educational code. Adapt to your needs.

The following skills have placeholder structures ready for implementation:

• machine-learning-engineer-skill
• data-scientist-skill
• data-analyst-skill
• prompt-engineer-skill
• devops-incident-responder-skill

Follow the existing patterns to implement these skills.