## GenAI System Requirements Interview Guide

### Business Stakeholders
- What business problem are we solving?
- What are the success criteria and KPIs?
- What is the expected ROI and timeline?
- What are the budget constraints?
- Who are the primary users and how many?

### Technical Stakeholders
- What are the technical constraints and requirements?
- What existing systems need integration?
- What are the performance and scalability needs?
- What security and compliance requirements exist?
- What infrastructure and resources are available?

### End Users
- What are your current workflows and pain points?
- How would you interact with this system?
- What would make this system valuable to you?
- What are your expectations for accuracy and speed?
- What would prevent you from adopting this system?

### Subject Matter Experts
- What domain knowledge is critical for success?
- What edge cases and exceptions exist?
- What are the quality standards and evaluation criteria?
- What data sources and validation methods exist?
- What regulatory or ethical considerations apply?

## Problem Statement Framework

### Current State
**Problem:** [Specific problem being solved]
**Impact:** [Business impact and pain points]
**Stakeholders:** [Who is affected and how]
**Current Solution:** [Existing approaches and limitations]

### Desired Future State
**Solution Vision:** [High-level solution approach]
**Value Proposition:** [Key benefits and improvements]
**Success Metrics:** [Quantifiable success criteria]
**User Experience:** [How users will interact with the solution]

### Constraints and Requirements
**Functional Requirements:**
- [List of must-have capabilities]
- [Input/output specifications]
- [Integration requirements]

**Non-Functional Requirements:**
- Performance: [Response time, throughput, availability]
- Scalability: [User load, data volume, geographic distribution]
- Security: [Data protection, access control, compliance]
- Usability: [User experience, accessibility, training needs]

**Constraints:**
- Technical: [Existing systems, technology stack, infrastructure]
- Business: [Budget, timeline, resources, regulatory]
- Data: [Availability, quality, privacy, governance]

# AI Service - Core GenAI functionality
from fastapi import FastAPI, HTTPException, BackgroundTasks
from pydantic import BaseModel
import openai
import weaviate
import redis
import logging
from typing import List, Optional
import asyncio

app = FastAPI(title="GenAI Service")

# Initialize clients
openai.api_key = os.getenv("OPENAI_API_KEY")
weaviate_client = weaviate.Client("http://vector-db:8000")
redis_client = redis.Redis(host="redis", port=6379, decode_responses=True)

class GenerationRequest(BaseModel):
    prompt: str
    user_id: str
    context: Optional[str] = None
    max_tokens: int = 1000
    temperature: float = 0.7

class GenerationResponse(BaseModel):
    content: str
    confidence_score: float
    processing_time: float
    metadata: dict

@app.post("/generate", response_model=GenerationResponse)
async def generate_content(request: GenerationRequest, background_tasks: BackgroundTasks):
    start_time = time.time()
    
    try:
        # Check cache first
        cache_key = f"generation:{hash(request.prompt + str(request.user_id))}"
        cached_result = redis_client.get(cache_key)
        if cached_result:
            return GenerationResponse.parse_raw(cached_result)
        
        # Retrieve relevant context from vector database
        if request.context:
            context_results = weaviate_client.query.get("Documents").with_additional(["certainty"]).with_near_text({"concepts": [request.context]}).with_limit(5).do()
            context = "\n".join([r["content"] for r in context_results["data"]["Get"]["Documents"]])
        else:
            context = ""
        
        # Generate content with OpenAI
        full_prompt = f"Context: {context}\n\nUser Request: {request.prompt}"
        
        response = await openai.ChatCompletion.acreate(
            model="gpt-4",
            messages=[
                {"role": "system", "content": "You are a helpful AI assistant."},
                {"role": "user", "content": full_prompt}
            ],
            max_tokens=request.max_tokens,
            temperature=request.temperature
        )
        
        content = response.choices[0].message.content
        processing_time = time.time() - start_time
        
        # Calculate confidence score (simplified)
        confidence_score = min(1.0, len(content) / request.max_tokens)
        
        result = GenerationResponse(
            content=content,
            confidence_score=confidence_score,
            processing_time=processing_time,
            metadata={
                "model": "gpt-4",
                "tokens_used": response.usage.total_tokens,
                "user_id": request.user_id
            }
        )
        
        # Cache result and log usage
        redis_client.setex(cache_key, 3600, result.json())  # 1 hour cache
        background_tasks.add_task(log_usage, request, result)
        
        return result
        
    except Exception as e:
        logging.error(f"Generation failed: {str(e)}")
        raise HTTPException(status_code=500, detail="Generation failed")

@app.get("/health")
async def health_check():
    return {"status": "healthy", "timestamp": time.time()}

# GenAI System Testing Framework
import pytest
import requests
from unittest.mock import Mock, patch
import json

class TestGenAIService:
    def setup_method(self):
        self.base_url = "http://localhost:8000"
        self.test_user_id = "test_user_123"
    
    def test_content_generation_success(self):
        """Test successful content generation"""
        payload = {
            "prompt": "Write a summary about climate change",
            "user_id": self.test_user_id,
            "max_tokens": 500,
            "temperature": 0.7
        }
        
        response = requests.post(f"{self.base_url}/generate", json=payload)
        assert response.status_code == 200
        
        data = response.json()
        assert "content" in data
        assert "confidence_score" in data
        assert data["confidence_score"] >= 0.0
        assert data["confidence_score"] <= 1.0
        assert len(data["content"]) > 0
    
    def test_input_validation(self):
        """Test input validation and error handling"""
        invalid_payload = {
            "prompt": "",  # Empty prompt should fail
            "user_id": self.test_user_id
        }
        
        response = requests.post(f"{self.base_url}/generate", json=invalid_payload)
        assert response.status_code == 422  # Validation error
    
    def test_content_quality(self):
        """Test generated content quality"""
        payload = {
            "prompt": "Explain quantum computing in simple terms",
            "user_id": self.test_user_id
        }
        
        response = requests.post(f"{self.base_url}/generate", json=payload)
        content = response.json()["content"]
        
        # Basic quality checks
        assert len(content.split()) >= 50  # Minimum word count
        assert "quantum" in content.lower()  # Relevance check
        assert not any(word in content.lower() for word in ["hate", "violence"])  # Safety check
    
    @patch('openai.ChatCompletion.acreate')
    def test_external_api_failure(self, mock_openai):
        """Test handling of external API failures"""
        mock_openai.side_effect = Exception("API Error")
        
        payload = {
            "prompt": "Test prompt",
            "user_id": self.test_user_id
        }
        
        response = requests.post(f"{self.base_url}/generate", json=payload)
        assert response.status_code == 500
        assert "Generation failed" in response.json()["detail"]

# Production Monitoring for GenAI Systems
import prometheus_client
from prometheus_client import Counter, Histogram, Gauge
import logging
import time
from functools import wraps

# Prometheus metrics
generation_requests = Counter('genai_generation_requests_total', 'Total generation requests', ['user_id', 'model'])
generation_latency = Histogram('genai_generation_duration_seconds', 'Time spent generating content')
active_users = Gauge('genai_active_users', 'Number of active users')
content_quality_score = Histogram('genai_content_quality_score', 'Content quality scores')
error_count = Counter('genai_errors_total', 'Total errors', ['error_type'])

def monitor_generation(func):
    """Decorator to monitor generation metrics"""
    @wraps(func)
    async def wrapper(*args, **kwargs):
        start_time = time.time()
        
        try:
            result = await func(*args, **kwargs)
            
            # Record metrics
            generation_requests.labels(
                user_id=kwargs.get('user_id', 'unknown'),
                model=result.metadata.get('model', 'unknown')
            ).inc()
            
            generation_latency.observe(result.processing_time)
            content_quality_score.observe(result.confidence_score)
            
            # Log structured data for analysis
            logging.info({
                "event": "generation_completed",
                "user_id": kwargs.get('user_id'),
                "processing_time": result.processing_time,
                "content_length": len(result.content),
                "confidence_score": result.confidence_score,
                "model": result.metadata.get('model'),
                "tokens_used": result.metadata.get('tokens_used')
            })
            
            return result
            
        except Exception as e:
            error_count.labels(error_type=type(e).__name__).inc()
            logging.error({
                "event": "generation_failed",
                "error": str(e),
                "user_id": kwargs.get('user_id'),
                "processing_time": time.time() - start_time
            })
            raise
    
    return wrapper

class ContentSafetyMonitor:
    """Monitor for harmful or inappropriate content"""
    
    def __init__(self):
        self.safety_violations = Counter('genai_safety_violations_total', 'Safety violations detected', ['violation_type'])
        
    def check_content_safety(self, content: str, user_id: str) -> dict:
        """Check generated content for safety issues"""
        violations = []
        
        # Check for harmful keywords (simplified example)
        harmful_keywords = ["violence", "hate", "harassment", "illegal"]
        for keyword in harmful_keywords:
            if keyword in content.lower():
                violations.append(f"harmful_keyword_{keyword}")
                self.safety_violations.labels(violation_type=keyword).inc()
        
        # Check content length (prevent extremely long outputs)
        if len(content) > 10000:
            violations.append("excessive_length")
            self.safety_violations.labels(violation_type="excessive_length").inc()
        
        return {
            "is_safe": len(violations) == 0,
            "violations": violations,
            "confidence": 1.0 - (len(violations) * 0.2)  # Simple confidence score
        }