# Poor prompt - vague and unclear
prompt1 = "Tell me about AI"

# Result: Generic, unfocused response


# Good prompt - specific and structured
prompt2 = "Explain how AI is used in healthcare, focusing on diagnostic imaging. Include 2 specific examples."

# Result: Targeted, useful information


# Great prompt - role, context, and constraints
prompt3 = """You are a healthcare technology expert.
Explain to hospital administrators how AI improves diagnostic imaging.
Focus on: 1) Cost savings 2) Accuracy improvements 3) Patient outcomes
Use specific examples and avoid technical jargon."""

# Result: Perfect for the intended audience!

```**Key Insight**: The same AI model produced three completely different outputs. The only difference? How we asked the question.


## What is Prompt Engineering?

Prompt engineering is the art and science of crafting inputs that guide AI models to produce desired outputs. Think of it as:

- 🎯**Like Programming, But With Words**: Instead of code, you use natural language
- 🎨**Part Art, Part Science**: Creativity meets systematic testing
- 🚀**Instant Results**: No model training required - changes take effect immediately
- 💰**Cost-Effective**: Achieve specialized behavior without expensive fine-tuning


### Real-World Impact

Prompt engineering today goes beyond typing a question. It involves crafting your input—your prompt—so the model delivers exactly what you need. Here's what companies are achieving:

- **Customer Service**: 70% reduction in response time with well-crafted prompts
- **Content Creation**: 10x faster blog post generation with audience-specific prompts
- **Code Generation**: 50% fewer bugs when using structured programming prompts
- **Data Analysis**: Complex SQL queries from natural language descriptions

Mastering prompts bridges the gap between your intent and the AI's response. Whether you're building a chatbot, automating business tasks, or prototyping features, prompt design makes your models more useful, reliable, and aligned with your goals.


## The Prompt Engineering Landscape

```mermaid
graph TD
    A[Your Intent] --> B{Prompt Engineering}
    B -->|Poor Prompt| C[Confused Output]
    B -->|Good Prompt| D[Useful Output]
    B -->|Great Prompt| E[Perfect Output]

    F[Components] --> B
    G[Context] --> F
    H[Instructions] --> F
    I[Examples] --> F
    J[Constraints] --> F

    style A fill:#e1f5fe,stroke:#0288d1
    style E fill:#c8e6c9,stroke:#388e3c
    style C fill:#ffcdd2,stroke:#d32f2f

"""Configuration module for prompt engineering examples.

This module is your project's foundation. It handles:
1. Environment variables (keeping secrets safe)
2. Project paths (preventing "file not found" errors)
3. Device detection (using GPU when available)
4. Model settings (easy to change without touching code)
"""

import os
from pathlib import Path
from dotenv import load_dotenv


# Load environment variables from .env file

# This keeps sensitive data like API keys out of your code
load_dotenv()


# Project paths using pathlib for cross-platform compatibility

# Path(__file__) gets this file's location, .parent.parent goes up two levels
PROJECT_ROOT = Path(__file__).parent.parent
DATA_DIR = PROJECT_ROOT / "data"        # For datasets
MODELS_DIR = PROJECT_ROOT / "models"    # For model cache


# Create directories if they don't exist

# This prevents "directory not found" errors later
DATA_DIR.mkdir(exist_ok=True)
MODELS_DIR.mkdir(exist_ok=True)


# Model configurations with sensible defaults

# os.getenv() reads from environment, falls back to default if not set
DEFAULT_MODEL = os.getenv("DEFAULT_MODEL", "bert-base-uncased")
BATCH_SIZE = int(os.getenv("BATCH_SIZE", "8"))      # How many examples to process at once
MAX_LENGTH = int(os.getenv("MAX_LENGTH", "512"))    # Maximum token length


# API keys (optional - only needed for certain models)

# Never hardcode these! Always use environment variables
OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
ANTHROPIC_API_KEY = os.getenv("ANTHROPIC_API_KEY")
HF_TOKEN = os.getenv("HUGGINGFACE_TOKEN")


# Smart device configuration
import torch

def get_device():
    """Automatically detect the best available device.

    Returns:
        str: 'mps' for Apple Silicon, 'cuda' for NVIDIA GPU, 'cpu' as fallback

    Why this matters:
    - MPS (Metal Performance Shaders): 5-10x faster on M1/M2 Macs
    - CUDA: 10-50x faster on NVIDIA GPUs
    - CPU: Works everywhere but slower
    """
    if torch.backends.mps.is_available():
        # Apple Silicon GPU acceleration
        return "mps"
    elif torch.cuda.is_available():
        # NVIDIA GPU acceleration
        return "cuda"
    else:
        # CPU fallback - works everywhere
        return "cpu"


# Get device once at module load
DEVICE = get_device()
print(f"🚀 Using device: {DEVICE}")

# Instead of this dangerous approach:
api_key = "sk-abc123..."  # ❌ Never do this!


# We do this:
api_key = os.getenv("OPENAI_API_KEY")  # ✅ Safe and secure

```**Why?**If you accidentally commit code with hardcoded keys to GitHub, bots scan for them within minutes. Using environment variables keeps secrets separate from code.


### 2. Smart Path Handling

```python

# Instead of error-prone string paths:
data_dir = "../data"  # ❌ Breaks on different systems


# We use pathlib:
DATA_DIR = PROJECT_ROOT / "data"  # ✅ Works everywhere

```**Why?**Path separators differ between Windows (\) and Unix (/). Pathlib handles this automatically.


### 3. Device Detection Magic

Our `get_device()` function is like a smart assistant that:

- Checks for Apple Silicon (M1/M2) → Uses Metal Performance Shaders
- Checks for NVIDIA GPU → Uses CUDA acceleration
- Falls back to CPU → Slower but works everywhere**Real Performance Differences**:

- CPU: Process 10 examples/second
- GPU: Process 100-500 examples/second
- That's the difference between waiting 1 minute vs 10 minutes!


### Setting Up Your Environment Variables

Create a `.env` file in your project root:

```bash

# .env file (never commit this to git!)
DEFAULT_MODEL=gpt2
BATCH_SIZE=16
MAX_LENGTH=512


# Optional API keys (only add if needed)
OPENAI_API_KEY=your-key-here
HUGGINGFACE_TOKEN=your-token-here

# .gitignore
.env
*.pyc
__pycache__/
data/
models/

# Install poetry if not already installed
curl -sSL <https://install.python-poetry.org> | python3 -


# Create new project
poetry new prompt-engineering-project
cd prompt-engineering-project


# Add dependencies
poetry add transformers==4.53.0 torch accelerate sentencepiece
poetry add --group dev jupyter ipykernel gradio streamlit langchain


# Activate environment
poetry shell

# Download and install mini-conda from <https://docs.conda.io/en/latest/miniconda.html>


# Create environment with Python 3.12.9
conda create -n prompt-engineering python=3.12.9
conda activate prompt-engineering


# Install packages
conda install -c pytorch -c huggingface transformers torch accelerate
conda install -c conda-forge sentencepiece gradio streamlit
pip install langchain

# Install pyenv (macOS/Linux)
curl <https://pyenv.run> | bash

# Configure shell (add to ~/.bashrc or ~/.zshrc)
export PATH="$HOME/.pyenv/bin:$PATH"
eval "$(pyenv init -)"


# Install Python 3.12.9 with pyenv
pyenv install 3.12.9
pyenv local 3.12.9


# Create virtual environment
python -m venv venv
source venv/bin/activate  # On Windows: venv\\Scripts\\activate


# Install packages
pip install transformers==4.53.0 torch accelerate sentencepiece
pip install gradio streamlit langchain jupyter

# test_setup.py
import sys
import torch
import transformers

print("✅ Python version:", sys.version)
print("✅ PyTorch version:", torch.__version__)
print("✅ Transformers version:", transformers.__version__)
print("✅ Device available:", torch.cuda.is_available() or torch.backends.mps.is_available())


# Test our configuration
from config import DEVICE, PROJECT_ROOT
print(f"✅ Using device: {DEVICE}")
print(f"✅ Project root: {PROJECT_ROOT}")

"""Main entry point for all examples."""

import sys
from pathlib import Path


# Add src to path
sys.path.append(str(Path(__file__).parent))

from named_entity_recognition import run_named_entity_recognition_examples
from question_answering import run_question_answering_examples
from text_generation import run_text_generation_examples
from multi_task_learning import run_multi_task_learning_examples
from summarization import run_summarization_examples
from conversational_ai import run_conversational_ai_examples
from document_processor import demo_document_processing
from prompt_manager import demo_prompt_manager
from secure_prompt import demo_secure_prompts

def print_section(title: str):
    """Print a formatted section header."""
    print("\\n" + "=" * 60)
    print(f"  {title}")
    print("=" * 60 + "\\n")

def main():
    """Run all examples."""
    print_section("CHAPTER 06: PROMPT ENGINEERING WITH TRANSFORMERS")
    print("Welcome! This script demonstrates prompt engineering concepts.")
    print("Each example builds on the previous concepts.\\n")

    print_section("1. NAMED ENTITY RECOGNITION")
    run_named_entity_recognition_examples()

    print_section("2. TEXT GENERATION")
    run_text_generation_examples()

    print_section("3. QUESTION ANSWERING")
    run_question_answering_examples()

    print_section("4. TEXT SUMMARIZATION")
    run_summarization_examples()

    print_section("5. CONVERSATIONAL AI")
    run_conversational_ai_examples()

    print_section("6. DOCUMENT PROCESSING")
    demo_document_processing()

    print_section("7. PROMPT MANAGEMENT")
    demo_prompt_manager()

    print_section("8. SECURE PROMPTS")
    demo_secure_prompts()

    print_section("9. MULTI-TASK LEARNING")
    run_multi_task_learning_examples()

    print_section("CONCLUSION")
    print("These examples demonstrate key prompt engineering concepts.")
    print("Try modifying the code to experiment with different approaches!")

if __name__ == "__main__":
    main()

python src/main.py

from text_generation import run_text_generation_examples
run_text_generation_examples()

"""Named Entity Recognition implementation."""

from transformers import pipeline, AutoTokenizer, AutoModel
import torch
from config import get_device, DEFAULT_MODEL

def run_named_entity_recognition_examples():
    """Run named entity recognition examples."""

    print(f"Loading model: {DEFAULT_MODEL}")
    device = get_device()
    print(f"Using device: {device}")

    # Example implementation
    tokenizer = AutoTokenizer.from_pretrained(DEFAULT_MODEL)
    model = AutoModel.from_pretrained(DEFAULT_MODEL)

    # Example text
    text = "Hugging Face Transformers make NLP accessible to everyone!"

    # Tokenize
    inputs = tokenizer(text, return_tensors="pt", padding=True, truncation=True)

    print(f"\\nInput text: {text}")
    print(f"Tokens: {tokenizer.convert_ids_to_tokens(inputs['input_ids'][0].tolist())}")
    print(f"Token IDs: {inputs['input_ids'][0].tolist()}")

    # Get model outputs
    with torch.no_grad():
        outputs = model(**inputs)

    print(f"\\nModel output shape: {outputs.last_hidden_state.shape}")
    print("Example completed successfully!")

if __name__ == "__main__":
    print("=== Named Entity Recognition Examples ===\\n")
    run_named_entity_recognition_examples()

# Count tokens before sending
token_count = len(tokenizer.encode(your_prompt))
print(f"Prompt uses {token_count} tokens")


# Leave room for response
max_prompt_tokens = model_max_tokens - desired_response_tokens

# Poor prompt - Too vague
prompt_poor = "Help customer with laptop"


# Better prompt - Adds context
prompt_better = "Customer says laptop won't turn on. Provide troubleshooting steps."


# Best prompt - Complete context + personality
prompt_best = """You are a friendly customer support agent for TechCorp.
Customer: My laptop won't turn on
Agent: I'm sorry to hear that. Let's troubleshoot this step by step:
1. First, let's check the power connection
2."""

# Result: Structured, empathetic troubleshooting guide

```**Why the progression matters:**- Poor: Model doesn't know the problem or tone
- Better: Model knows the issue but might be too technical
- Best: Model has role, empathy cue, and structured approach


### 2. Technical Documentation

```python

# Evolution of a technical prompt
prompt_v1 = "Explain Docker"

# Result: Too general, might be too basic or too advanced

prompt_v2 = "Explain Docker containers to a developer"

# Result: Better targeted but still lacks context

prompt_v3 = """You are a technical writer. Explain Docker containers to a developer
who knows Python but is new to containerization. Use analogies when helpful."""

# Result: Perfect balance - technical but accessible

# Demonstrating temperature impact
prompt = "Write a tagline for an AI coffee maker"


# Temperature 0.3 - Safe and predictable

# Output: "Smart Coffee for Smart People"


# Temperature 0.7 - Balanced creativity

# Output: "Where Silicon Meets Arabica"


# Temperature 0.9 - Wild and creative

# Output: "Your Morning Brew, Now With Neural Networks!"

"""Multi-style text summarization examples."""

from transformers import pipeline
import torch
from config import DEVICE

def run_summarization_examples():
    """Run text summarization examples with different styles."""
    print("Initializing summarization pipeline...")

    # Use a smaller summarization model for better performance
    summarizer = pipeline(
        "summarization",
        model="sshleifer/distilbart-cnn-12-6",  # Smaller distilled version
        device=0 if DEVICE == "cuda" else -1
    )

    # For style-based summarization, we'll also use a text generation model
    text_gen = pipeline(
        "text-generation",
        model="gpt2",
        device=0 if DEVICE == "cuda" else -1
    )

    # Sample business article
    article = """
    Apple reported record-breaking Q4 2024 earnings with revenue of $123.9 billion,
    up 8% year-over-year. The company's services division showed particularly strong
    growth at 12%, while iPhone sales remained stable. CEO Tim Cook highlighted the
    successful launch of the iPhone 15 Pro and growing adoption of Apple Intelligence
    features. The company also announced a $110 billion share buyback program and
    increased its dividend by 4%. Looking forward, Apple guided for continued growth
    in the services sector but warned of potential headwinds in the China market due
    to increased competition from local manufacturers.
    """

    # Example 1: Standard summarization
    print("\\n1. STANDARD SUMMARIZATION")
    print("-" * 50)
    print("Original article:", article[:100] + "...")

    summary = summarizer(article, max_length=60, min_length=30, do_sample=False)
    print(f"\\nStandard summary: {summary[0]['summary_text']}")

    # Example 2: Multi-style summarization using prompts
    print("\\n\\n2. MULTI-STYLE SUMMARIZATION")
    print("-" * 50)

    prompts = {
        "executive": """You are an executive assistant. Provide a 2-sentence executive summary
focusing on key financial metrics and strategic implications:

{text}

Executive Summary:""",

        "investor": """You are a financial analyst. Summarize for investors, highlighting:
- Revenue and growth figures
- Key business segments performance
- Forward guidance and risks

Text: {text}

Investor Summary:""",

        "technical": """You are a tech journalist. Summarize focusing on:
- Product launches and adoption
- Technology innovations mentioned
- Competitive landscape

Text: {text}

Tech Summary:"""
    }

    for audience, prompt_template in prompts.items():
        prompt = prompt_template.format(text=article)
        response = text_gen(
            prompt,
            max_new_tokens=150,
            temperature=0.7,
            do_sample=True,
            pad_token_id=text_gen.tokenizer.eos_token_id
        )

        # Extract the summary part
        full_text = response[0]['generated_text']
        if "Summary:" in full_text:
            summary_text = full_text.split("Summary:")[-1].strip()
        else:
            summary_text = full_text[len(prompt):].strip()

        print(f"\\n{audience.upper()} SUMMARY:")
        print(summary_text)

    # Example 3: Length-controlled summarization
    print("\\n\\n3. LENGTH-CONTROLLED SUMMARIZATION")
    print("-" * 50)

    lengths = [
        ("Tweet (280 chars)", 50),
        ("One-liner", 20),
        ("Paragraph", 100)
    ]

    for name, max_len in lengths:
        summary = summarizer(
            article,
            max_length=max_len,
            min_length=max_len // 2,
            do_sample=False
        )
        print(f"\\n{name}:")
        print(summary[0]['summary_text'])

    # Example 4: Extractive vs Abstractive comparison
    print("\\n\\n4. EXTRACTIVE VS ABSTRACTIVE SUMMARIZATION")
    print("-" * 50)

    # Extractive-style (selecting key sentences)
    extractive_prompt = """Extract the 3 most important sentences from this text:

{text}

Important sentences:
1."""

    response = text_gen(
        extractive_prompt.format(text=article),
        max_new_tokens=150,
        temperature=0.3,
        do_sample=True,
        pad_token_id=text_gen.tokenizer.eos_token_id
    )
    print("Extractive-style summary:")
    print(response[0]['generated_text'].split("Important sentences:\\n1.")[-1])

    # Abstractive (already shown above with BART)
    print("\\nAbstractive summary (BART):")
    print(summary[0]['summary_text'])

    print("\\n" + "=" * 50)
    print("Summarization examples completed!")

if __name__ == "__main__":
    run_summarization_examples()

def get_cached_summary(text_hash, audience_type):
    cache_key = f"{text_hash}_{audience_type}"
    if cache_key in summary_cache:
        return summary_cache[cache_key]
    # Generate and cache new summary
    summary = generate_summary(text, audience_type)
    summary_cache[cache_key] = summary
    return summary

# Simple but problematic
def basic_qa(question, context):
    prompt = f"Context: {context}\\nQuestion: {question}\\nAnswer:"
    return model(prompt)


# Problems:

# - No verification of accuracy

# - Can hallucinate beyond context

# - No confidence indication

```**Real Example of Failure:**- Context: "Our product costs $99"
- Question: "What features are included?"
- Bad Output: "The $99 plan includes unlimited storage, API access..." (Hallucinated!)


### Evolution Stage 2: Add Context Grounding

```python

# Better - forces context-only answers
def grounded_qa(question, context):
    prompt = f"""Context: {context}
Question: {question}
Answer based ONLY on the context. If not in context, say "Not found"."""
    return model(prompt)


# Improvement: Reduces hallucination

# Still missing: Confidence scoring

```**Improvement in Action:**- Same question now returns: "The context doesn't specify what features are included."
- Better! But users might want to know HOW confident the system is.


### Evolution Stage 3: Add Self-Verification

```python

# Production-ready with verification
def verified_qa(question, context):
    # Get answer
    answer = grounded_qa(question, context)

    # Verify answer
    verify_prompt = f"""
    Context: {context}
    Question: {question}
    Proposed Answer: {answer}
    Is this accurate? Yes/No"""

    verification = model(verify_prompt)
    return {"answer": answer, "verified": "Yes" in verification}


# Now we have confidence indication!

```**Production Benefits:**- Customer Support: Routes low-confidence answers to human agents
- Medical/Legal: Only shows high-confidence answers
- Education: Provides different explanations based on confidence


## SmartQASystem Architecture

```mermaid
classDiagram
    class SmartQASystem {
        -model: Pipeline
        -context_template: str
        +__init__(model)
        +answer_with_confidence(question, context, domain) Dict
    }

    class Pipeline {
        +__call__(prompt, kwargs)
    }

    SmartQASystem --> Pipeline : uses

"""Question answering examples with smart QA system implementation.

This module demonstrates how to build a production-ready QA system that:
1. Grounds answers in provided context (prevents hallucination)
2. Self-verifies accuracy (builds trust)
3. Provides confidence scores (enables smart routing)
4. Adapts to different domains (better responses)

Key insight: It's better to say "I don't know" than to guess wrong.
"""

from transformers import pipeline
import json
from typing import Dict, List
from config import DEVICE

class SmartQASystem:
    """Production-ready question answering system with confidence scoring.

    Why this architecture?
    - Separation of concerns: Model logic vs business logic
    - Easy to swap models without changing verification logic
    - Domain templates allow customization per use case
    - Self-verification catches hallucination before users see it
    """

    def __init__(self, model=None):
        """Initialize the QA system with a text generation model.

        Args:
            model: Optional pre-loaded model. If None, loads GPT-2.
                  This flexibility allows using larger models in production
                  while keeping examples runnable on any hardware.
        """
        if model is None:
            self.model = pipeline(
                "text-generation",
                model="gpt2",  # Small model for demo accessibility
                device=0 if DEVICE == "cuda" else -1
            )
        else:
            self.model = model

        self.context_template = """You are a helpful AI assistant with expertise in {domain}.

Context: {context}

Question: {question}

Instructions:
1. Answer based ONLY on the provided context
2. If the answer isn't in the context, say "I don't have enough information"
3. Be concise but complete
4. Use bullet points for multiple items

Answer:"""

    def answer_with_confidence(self, question: str, context: str, domain: str = "general") -> Dict:
        """Answer a question with confidence scoring."""
        # First attempt: Direct answer
        prompt = self.context_template.format(
            domain=domain,
            context=context,
            question=question
        )

        response = self.model(
            prompt,
            max_new_tokens=200,
            temperature=0.3,  # Lower temperature for factual accuracy
            do_sample=True,
            pad_token_id=self.model.tokenizer.eos_token_id
        )

        # Extract answer after "Answer:"
        full_response = response[0]['generated_text']
        if "Answer:" in full_response:
            answer = full_response.split("Answer:")[-1].strip()
        else:
            answer = full_response[len(prompt):].strip()

        # Self-verification prompt
        verify_prompt = f"""Given this context: {context}

Question: {question}
Answer provided: {answer}

Is this answer accurate and complete based ONLY on the context?
Respond with 'Yes' or 'No' and explain briefly."""

        verification = self.model(
            verify_prompt,
            max_new_tokens=50,
            temperature=0.3,
            do_sample=True,
            pad_token_id=self.model.tokenizer.eos_token_id
        )

        verification_text = verification[0]['generated_text']

        return {
            "answer": answer,
            "verification": verification_text,
            "confidence": "high" if "Yes" in verification_text else "low"
        }

def run_question_answering_examples():
    """Run question answering examples from the article."""
    print("Initializing Question Answering System...")
    qa_system = SmartQASystem()

    # Example 1: Company knowledge base
    print("\\n1. COMPANY KNOWLEDGE BASE Q&A")
    print("-" * 50)

    context = """
TechCorp's new AI platform, CloudMind, offers three tiers:
- Starter: $99/month, 10,000 API calls, basic models
- Professional: $499/month, 100,000 API calls, advanced models, priority support
- Enterprise: Custom pricing, unlimited calls, dedicated infrastructure, SLA

CloudMind supports Python, JavaScript, and Java SDKs. The platform includes
pre-trained models for NLP, computer vision, and speech recognition. All tiers
include automatic scaling and 99.9% uptime guarantee.
"""

    questions = [
        "What programming languages does CloudMind support?",
        "How much does the Professional tier cost?",
        "Does CloudMind offer a free trial?",  # Not in context
        "What's included in the Enterprise tier?"
    ]

    for q in questions:
        result = qa_system.answer_with_confidence(q, context, "tech products")
        print(f"\\nQ: {q}")
        print(f"A: {result['answer']}")
        print(f"Confidence: {result['confidence']}")

    # Example 2: Technical documentation Q&A
    print("\\n\\n2. TECHNICAL DOCUMENTATION Q&A")
    print("-" * 50)

    tech_context = """
The Transformer architecture consists of an encoder and decoder. The encoder
processes the input sequence and creates representations. The decoder generates
the output sequence. Both use self-attention mechanisms and feed-forward networks.

Key components:
- Multi-head attention: Allows the model to focus on different positions
- Positional encoding: Adds position information to embeddings
- Layer normalization: Stabilizes training
- Residual connections: Help with gradient flow

The model uses 6 encoder and 6 decoder layers by default.
"""

    tech_questions = [
        "What are the main components of a Transformer?",
        "How many encoder layers does a standard Transformer have?",
        "What is the purpose of positional encoding?",
        "Does the Transformer use LSTM cells?"  # Testing negative case
    ]

    for q in tech_questions:
        result = qa_system.answer_with_confidence(q, tech_context, "machine learning")
        print(f"\\nQ: {q}")
        print(f"A: {result['answer']}")
        print(f"Confidence: {result['confidence']}")

    # Example 3: Simple Q&A without context
    print("\\n\\n3. ZERO-SHOT QUESTION ANSWERING")
    print("-" * 50)

    general_questions = [
        "What is the capital of France?",
        "How do plants produce energy?",
        "What is 15% of 200?"
    ]

    for q in general_questions:
        # For zero-shot, we'll use a simpler approach
        prompt = f"Question: {q}\\nAnswer:"
        response = qa_system.model(
            prompt,
            max_new_tokens=50,
            temperature=0.5,
            do_sample=True,
            pad_token_id=qa_system.model.tokenizer.eos_token_id
        )
        answer = response[0]['generated_text'].split("Answer:")[-1].strip()
        print(f"\\nQ: {q}")
        print(f"A: {answer}")

    print("\\n" + "=" * 50)
    print("Question answering examples completed!")

if __name__ == "__main__":
    run_question_answering_examples()

# Bad prompt (allows hallucination):
"What's the capital of Atlantis?"

# Model might confidently make up an answer


# Good prompt (grounds in reality):
"Based on the provided context, what's the capital?
Context: [your data here]
If not in context, say 'Information not available'"

"""Conversational AI examples with specialized assistants.

This module shows how to build production-ready conversational AI that:
1. Maintains consistent personality across conversations
2. Remembers context within reasonable limits
3. Adapts responses based on domain expertise
4. Handles edge cases gracefully

Key insight: Personality consistency is more important than perfect answers.
Users forgive mistakes but not personality breaks.
"""

from transformers import pipeline
from typing import List
from config import DEVICE

class ConversationalAssistant:
    """Domain-specific conversational agent with role prompting and memory.

    Design decisions:
    - Limited history (5 exchanges) prevents context overflow
    - Role + personality separation allows flexible combinations
    - Temperature tuning per domain provides appropriate responses
    - Graceful truncation handles long conversations
    """

    def __init__(self, model=None, role: str = "", personality: str = ""):
        """Initialize the conversational assistant.

        Args:
            model: Pre-loaded model or None to load GPT-2
            role: The assistant's profession/expertise (e.g., "a medical professional")
            personality: Behavioral traits (e.g., "empathetic and thorough")
        """
        if model is None:
            self.model = pipeline(
                "text-generation",
                model="gpt2",  # Small model for demo
                device=0 if DEVICE == "cuda" else -1
            )
        else:
            self.model = model

        self.role = role
        self.personality = personality
        self.conversation_history: List[str] = []
        self.max_history = 5  # Prevents context overflow

    def get_system_prompt(self) -> str:
        """Get the system prompt for this assistant."""
        return f"""You are {self.role}. {self.personality}

Guidelines:
- Stay in character
- Be helpful but maintain appropriate boundaries
- Use domain-specific terminology when relevant
- Keep responses concise but informative

Current conversation:"""

    def chat(self, user_input: str) -> str:
        """Process user input and generate response."""
        # Add user input to history
        self.conversation_history.append(f"User: {user_input}")

        # Construct full prompt with history
        full_prompt = self.get_system_prompt() + "\\n"

        # Include recent history
        start_idx = max(0, len(self.conversation_history) - self.max_history * 2)
        for msg in self.conversation_history[start_idx:]:
            full_prompt += msg + "\\n"

        full_prompt += "Assistant:"

        # Limit prompt length to avoid model limits
        if len(full_prompt) > 800:
            # Keep only recent history
            full_prompt = self.get_system_prompt() + "\\n"
            start_idx = max(0, len(self.conversation_history) - 2)
            for msg in self.conversation_history[start_idx:]:
                full_prompt += msg + "\\n"
            full_prompt += "Assistant:"

        # Generate response
        response = self.model(
            full_prompt,
            max_new_tokens=80,
            temperature=0.8,
            do_sample=True,
            pad_token_id=self.model.tokenizer.eos_token_id,
            truncation=True
        )

        # Extract only the new response
        full_response = response[0]['generated_text']
        if "Assistant:" in full_response:
            assistant_response = full_response.split("Assistant:")[-1].strip()
        else:
            assistant_response = full_response[len(full_prompt):].strip()

        # Add to history
        self.conversation_history.append(f"Assistant: {assistant_response}")

        return assistant_response

    def reset_conversation(self):
        """Reset conversation history."""
        self.conversation_history = []

def run_conversational_ai_examples():
    """Run conversational AI examples with different specialized assistants."""
    print("Initializing Conversational AI Examples...")

    # Create specialized assistants
    assistants = {
        "medical": ConversationalAssistant(
            role="a medical information assistant",
            personality="You are knowledgeable, empathetic, and always remind users to consult healthcare professionals for personal medical advice"
        ),
        "tech_support": ConversationalAssistant(
            role="a technical support specialist",
            personality="You are patient, detail-oriented, and skilled at explaining technical concepts in simple terms"
        ),
        "tutor": ConversationalAssistant(
            role="a friendly math tutor",
            personality="You are encouraging, break down problems step-by-step, and use examples to explain concepts"
        ),
        "chef": ConversationalAssistant(
            role="a professional chef",
            personality="You are creative, passionate about food, and enjoy sharing cooking tips and recipes"
        )
    }

    # Example 1: Medical Assistant
    print("\\n1. MEDICAL ASSISTANT DEMO")
    print("-" * 50)

    medical_conversations = [
        "I've been having headaches lately",
        "What might cause them?",
        "Should I be worried?"
    ]

    medical_assistant = assistants["medical"]
    for user_input in medical_conversations:
        print(f"\\nUser: {user_input}")
        response = medical_assistant.chat(user_input)
        print(f"Assistant: {response}")

    # Example 2: Tech Support
    print("\\n\\n2. TECH SUPPORT DEMO")
    print("-" * 50)

    tech_conversations = [
        "My computer is running slowly",
        "I haven't restarted in weeks",
        "How do I check what's using memory?"
    ]

    tech_support = assistants["tech_support"]
    for user_input in tech_conversations:
        print(f"\\nUser: {user_input}")
        response = tech_support.chat(user_input)
        print(f"Assistant: {response}")

    # Example 3: Math Tutor
    print("\\n\\n3. MATH TUTOR DEMO")
    print("-" * 50)

    tutor_conversations = [
        "Can you help me understand fractions?",
        "What's 1/2 + 1/3?",
        "Why do we need a common denominator?"
    ]

    tutor = assistants["tutor"]
    for user_input in tutor_conversations:
        print(f"\\nUser: {user_input}")
        response = tutor.chat(user_input)
        print(f"Assistant: {response}")

    # Example 4: Context-aware conversation
    print("\\n\\n4. CONTEXT-AWARE CONVERSATION (CHEF)")
    print("-" * 50)

    chef_conversations = [
        "I want to make pasta for dinner",
        "I have tomatoes, garlic, and basil",
        "How long should I cook it?",
        "Any tips for making it restaurant-quality?"
    ]

    chef = assistants["chef"]
    for user_input in chef_conversations:
        print(f"\\nUser: {user_input}")
        response = chef.chat(user_input)
        print(f"Assistant: {response}")

    # Example 5: Conversation reset demonstration
    print("\\n\\n5. CONVERSATION RESET DEMO")
    print("-" * 50)

    print("Starting new conversation with tech support...")
    tech_support.reset_conversation()

    new_conversation = [
        "Hi, I need help with my printer",
        "It's not printing anything",
        "The lights are on but nothing happens"
    ]

    for user_input in new_conversation:
        print(f"\\nUser: {user_input}")
        response = tech_support.chat(user_input)
        print(f"Assistant: {response}")

    print("\\n" + "=" * 50)
    print("Conversational AI examples completed!")

if __name__ == "__main__":
    run_conversational_ai_examples()

# Weak: Just a label
"You are a doctor."


# Strong: Personality + Constraints + Style
"""You are a medical information assistant.
Personality: Knowledgeable, empathetic, cautious
Constraints: Always remind users to consult healthcare professionals
Style: Clear, non-technical language, reassuring tone"""

class ConversationSession:
    def __init__(self, session_id, assistant_type):
        self.session_id = session_id
        self.assistant = create_assistant(assistant_type)
        self.created_at = datetime.now()
        self.last_active = datetime.now()

    def cleanup_old_sessions(self, timeout_minutes=30):
        # Prevent memory leaks from abandoned sessions
        pass

```**Handling Context Switches**:

```python

# User: "Actually, can you help with cooking instead?"
if detect_context_switch(user_input):
    response = "I'd be happy to help with cooking! Let me switch to our culinary expert."
    assistant = switch_assistant("chef")

"""Multi-stage document processing pipeline.

This module demonstrates enterprise-grade document processing:
1. Extraction: Pull structured data from unstructured text
2. Analysis: Understand sentiment, urgency, and implications
3. Transformation: Convert to appropriate output formats
4. Quality Assurance: Verify output meets requirements

Key insight: Complex tasks become manageable when broken into stages.
Each stage can fail gracefully without breaking the entire pipeline.
"""

from transformers import pipeline
from typing import Dict, Any
import json
from config import DEVICE

class DocumentProcessor:
    """Multi-stage document processing pipeline.

    Architecture benefits:
    - Stages can use different models (extraction vs generation)
    - Failed stages don't corrupt successful ones
    - Easy to add/remove/modify stages
    - Each stage can be unit tested independently
    """

    def __init__(self, model=None):
        """Initialize the document processor.

        In production, you might have:
        - Extraction model (BERT-based)
        - Sentiment model (fine-tuned classifier)
        - Generation model (GPT-based)
        - QA model (verification stage)
        """
        if model is None:
            self.model = pipeline(
                "text-generation",
                model="gpt2",
                device=0 if DEVICE == "cuda" else -1
            )
        else:
            self.model = model

    def process_document(self, document: str, output_format: str = "report") -> Dict[str, Any]:
        """Process document through multiple stages."""

        # Stage 1: Extract key information
        extraction_prompt = f"""Extract the following from this document:
- Main topic
- Key points (up to 5)
- Important dates/deadlines
- Action items

Document: {document}

Format as JSON:"""

        # Truncate prompt if too long
        if len(extraction_prompt) > 800:
            extraction_prompt = extraction_prompt[:800] + "..."

        extracted = self.model(
            extraction_prompt,
            max_new_tokens=100,
            temperature=0.5,
            do_sample=True,
            pad_token_id=self.model.tokenizer.eos_token_id,
            truncation=True
        )
        extracted_text = extracted[0]['generated_text']

        # Stage 2: Analyze sentiment and tone
        sentiment_prompt = f"""Analyze the tone and sentiment of this document:
{document}

Provide:
- Overall sentiment (positive/negative/neutral)
- Tone (formal/casual/urgent/informative)
- Key emotional indicators"""

        # Truncate document for sentiment analysis
        if len(document) > 500:
            sentiment_prompt = f"""Analyze the tone and sentiment of this document:
{document[:500]}...

Provide:
- Overall sentiment (positive/negative/neutral)
- Tone (formal/casual/urgent/informative)
- Key emotional indicators"""

        sentiment = self.model(
            sentiment_prompt,
            max_new_tokens=80,
            temperature=0.5,
            do_sample=True,
            pad_token_id=self.model.tokenizer.eos_token_id,
            truncation=True
        )
        sentiment_text = sentiment[0]['generated_text']

        # Stage 3: Generate formatted output
        if output_format == "report":
            format_prompt = f"""Based on this analysis, create a professional report:

Extracted Information:
{extracted_text}

Sentiment Analysis:
{sentiment_text}

Create a well-structured executive report with:
1. Executive Summary
2. Key Findings
3. Recommendations
4. Next Steps"""

        elif output_format == "email":
            format_prompt = f"""Convert this analysis into a professional email:

Information: {extracted_text}

Write a concise email that:
- Summarizes the main points
- Highlights action items
- Maintains appropriate tone
- Includes a clear call-to-action"""

        else:  # Default to summary
            format_prompt = f"""Create a concise summary based on:

Extracted Information:
{extracted_text}

Sentiment Analysis:
{sentiment_text}

Provide a clear, actionable summary."""

        # Ensure format prompt isn't too long
        if len(format_prompt) > 900:
            # Truncate the extracted and sentiment text if needed
            format_prompt = format_prompt[:900] + "..."

        final_output = self.model(
            format_prompt,
            max_new_tokens=150,
            temperature=0.7,
            do_sample=True,
            pad_token_id=self.model.tokenizer.eos_token_id,
            truncation=True
        )

        return {
            "extracted_info": extracted_text,
            "sentiment": sentiment_text,
            "formatted_output": final_output[0]['generated_text']
        }

    def extract_entities(self, document: str) -> Dict[str, Any]:
        """Extract named entities from document."""
        entity_prompt = f"""Extract the following entities from this document:
- People mentioned
- Organizations
- Locations
- Dates
- Monetary values

Document: {document}

List each category:"""

        response = self.model(
            entity_prompt,
            max_new_tokens=150,
            temperature=0.3,
            do_sample=True,
            pad_token_id=self.model.tokenizer.eos_token_id
        )

        return {"entities": response[0]['generated_text']}

    def summarize_by_section(self, document: str) -> Dict[str, Any]:
        """Summarize document section by section."""
        section_prompt = f"""Break down this document into logical sections and summarize each:

Document: {document}

Section summaries:"""

        response = self.model(
            section_prompt,
            max_new_tokens=250,
            temperature=0.5,
            do_sample=True,
            pad_token_id=self.model.tokenizer.eos_token_id
        )

        return {"section_summaries": response[0]['generated_text']}

def demo_document_processing():
    """Demonstrate document processing capabilities."""
    print("Document Processing Pipeline Demo")
    print("=" * 50)

    processor = DocumentProcessor()

    # Sample documents
    documents = {
        "business_update": """
Team,

Following our Q3 review, I wanted to share some critical updates. Our revenue
exceeded targets by 15%, reaching $4.2M. However, customer churn increased to
8%, primarily due to onboarding issues.

Immediate action required:
1. Review and revamp onboarding process by Nov 15
2. Schedule customer feedback sessions next week
3. Prepare retention strategy presentation for board meeting on Nov 20

The competitive landscape is intensifying, but our product differentiation
remains strong. We must act quickly to maintain our market position.

Best regards,
Sarah Chen
VP of Product
""",

        "technical_report": """
System Performance Analysis - October 2024

Executive Summary:
Our infrastructure has shown 99.8% uptime this month, exceeding our SLA
requirements. However, response times have degraded by 12% due to increased
traffic.

Key Findings:
- Database queries are the primary bottleneck
- CDN cache hit rate is only 72% (target: 85%)
- API response times average 250ms (target: 200ms)

Recommendations:
1. Implement database query optimization
2. Review and update CDN caching rules
3. Consider horizontal scaling for API servers

Timeline: Complete optimizations by end of Q4 2024.
""",

        "customer_feedback": """
Product Review Summary - Mobile App v3.2

We've analyzed 500+ customer reviews from the past month. Overall satisfaction
has improved to 4.2/5 stars, up from 3.8 in the previous version.

Positive feedback focuses on:
- Improved UI design (mentioned by 78% of positive reviews)
- Faster load times (65% mentions)
- New features like dark mode (82% approval)

Areas for improvement:
- Battery consumption still high (45% of complaints)
- Sync issues with desktop version (30% of complaints)
- Limited offline functionality (25% requests)

Suggested priorities for v3.3:
1. Optimize battery usage
2. Fix sync reliability
3. Expand offline capabilities
"""
    }

    # Example 1: Process business update as report
    print("\\n1. BUSINESS UPDATE → EXECUTIVE REPORT")
    print("-" * 50)

    result = processor.process_document(documents["business_update"], output_format="report")
    print("Formatted Output:")
    print(result["formatted_output"])

    # Example 2: Process technical report as email
    print("\\n\\n2. TECHNICAL REPORT → EMAIL")
    print("-" * 50)

    result = processor.process_document(documents["technical_report"], output_format="email")
    print("Email Output:")
    print(result["formatted_output"])

    # Example 3: Extract entities
    print("\\n\\n3. ENTITY EXTRACTION")
    print("-" * 50)

    entities = processor.extract_entities(documents["business_update"])
    print("Extracted Entities:")
    print(entities["entities"])

    # Example 4: Section-by-section summary
    print("\\n\\n4. SECTION-BY-SECTION SUMMARY")
    print("-" * 50)

    sections = processor.summarize_by_section(documents["customer_feedback"])
    print("Section Summaries:")
    print(sections["section_summaries"])

    # Example 5: Multi-document processing
    print("\\n\\n5. MULTI-DOCUMENT BATCH PROCESSING")
    print("-" * 50)

    print("Processing all documents as summaries...")
    for doc_name, doc_content in documents.items():
        print(f"\\n{doc_name.upper()}:")
        result = processor.process_document(doc_content, output_format="summary")
        # Show just the final output
        output = result["formatted_output"]
        if "Provide a clear, actionable summary." in output:
            summary = output.split("Provide a clear, actionable summary.")[-1].strip()
        else:
            summary = output[len(doc_content):].strip()
        print(summary[:200] + "..." if len(summary) > 200 else summary)

    print("\\n" + "=" * 50)
    print("Document processing demo completed!")

if __name__ == "__main__":
    demo_document_processing()

def extract_with_retry(document, max_retries=3):
    for attempt in range(max_retries):
        try:
            result = extract_information(document)
            if validate_extraction(result):
                return result
        except Exception as e:
            if attempt == max_retries - 1:
                return fallback_extraction(document)

import asyncio

async def process_document_parallel(document):
    # Run independent stages in parallel
    extraction_task = asyncio.create_task(extract_info(document))
    sentiment_task = asyncio.create_task(analyze_sentiment(document))
    entity_task = asyncio.create_task(extract_entities(document))

    # Wait for all parallel tasks
    extraction_result = await extraction_task
    sentiment_result = await sentiment_task
    entity_result = await entity_task

    # Sequential final formatting using all results
    return format_output(extraction_result, sentiment_result, entity_result)


# Real-world impact: 3x faster for multi-stage pipelines

```**2. Smart Caching Strategy**:

```python
from functools import lru_cache
import hashlib

def document_hash(document: str) -> str:
    """Create stable hash for caching."""
    return hashlib.md5(document.encode()).hexdigest()

@lru_cache(maxsize=1000)
def cached_extraction(doc_hash: str, document: str):
    """Cache extraction results by document hash."""
    return extract_information(document)


# Usage
doc_hash = document_hash(document)
result = cached_extraction(doc_hash, document)


# Real-world impact: 90% cache hit rate for repeated documents

```**3. Batch Processing**:

```python
def process_document_batch(documents: List[str], batch_size: int = 10):
    """Process multiple documents efficiently."""
    results = []

    for i in range(0, len(documents), batch_size):
        batch = documents[i:i + batch_size]
        # Process batch in parallel
        batch_results = await asyncio.gather(*[
            process_document_parallel(doc) for doc in batch
        ])
        results.extend(batch_results)

    return results


# Real-world impact: 10x throughput for bulk processing

try:
    advanced_summary = multi_stage_pipeline(document)
except StageFailure:
    basic_summary = simple_summarization(document)
    log_degradation("Fell back to simple summarization")
    return basic_summary

"""Production-ready prompt management system."""

import time
import logging
from datetime import datetime
from typing import Dict, List, Optional, Any

class ProductionPromptManager:
    """Production-ready prompt management system with versioning and analytics."""

    def __init__(self, model=None):
        """Initialize the prompt manager."""
        self.model = model
        self.prompt_versions: Dict[str, Dict[str, Any]] = {}
        self.usage_logs: List[Dict[str, Any]] = []
        self.performance_metrics: Dict[str, Any] = {}

        # Setup logging
        logging.basicConfig(level=logging.INFO)
        self.logger = logging.getLogger(__name__)

    def register_prompt(
        self,
        name: str,
        version: str,
        template: str,
        metadata: Optional[Dict] = None
    ):
        """Register a new prompt version."""
        key = f"{name}_v{version}"
        self.prompt_versions[key] = {
            "template": template,
            "metadata": metadata or {},
            "created_at": datetime.now(),
            "usage_count": 0,
            "avg_latency": 0,
            "success_rate": 1.0
        }
        self.logger.info(f"Registered prompt: {key}")

    def execute_prompt(
        self,
        name: str,
        version: str,
        variables: Dict[str, Any],**generation_kwargs
    ) -> Dict[str, Any]:
        """Execute a prompt with monitoring."""
        key = f"{name}_v{version}"

        if key not in self.prompt_versions:
            raise ValueError(f"Prompt {key} not found")

        start_time = time.time()
        prompt_data = self.prompt_versions[key]

        try:
            # Format prompt with variables
            prompt = prompt_data["template"].format(**variables)

            # Generate response (mock if no model provided)
            if self.model:
                response = self.model(prompt,**generation_kwargs)
                response_text = response[0]['generated_text']
            else:
                # Mock response for demonstration
                response_text = f"Mock response for prompt: {name} v{version}"

            # Calculate metrics
            latency = time.time() - start_time
            success = True

            # Update metrics
            prompt_data["usage_count"] += 1
            prompt_data["avg_latency"] = (
                (prompt_data["avg_latency"] * (prompt_data["usage_count"] - 1) + latency)
                / prompt_data["usage_count"]
            )

            # Log usage
            self.usage_logs.append({
                "prompt_key": key,
                "timestamp": datetime.now(),
                "latency": latency,
                "success": success,
                "input_length": len(prompt),
                "output_length": len(response_text)
            })

            return {
                "response": response_text,
                "metrics": {
                    "latency": latency,
                    "prompt_version": key,
                    "timestamp": datetime.now()
                }
            }

        except Exception as e:
            self.logger.error(f"Error executing prompt {key}: {str(e)}")
            prompt_data["success_rate"] *= 0.95  # Decay success rate
            raise

    def get_best_prompt(self, name: str) -> Optional[str]:
        """Get best performing prompt version."""
        versions = [k for k in self.prompt_versions.keys() if k.startswith(name)]

        if not versions:
            return None

        # Score based on success rate and latency
        best_version = max(versions, key=lambda v:
            self.prompt_versions[v]["success_rate"] /
            (self.prompt_versions[v]["avg_latency"] + 1)
        )

        return best_version

    def get_analytics(self) -> Dict[str, Any]:
        """Get prompt performance analytics."""
        return {
            "total_prompts": len(self.prompt_versions),
            "total_executions": len(self.usage_logs),
            "prompt_performance": {
                k: {
                    "usage_count": v["usage_count"],
                    "avg_latency": round(v["avg_latency"], 3),
                    "success_rate": round(v["success_rate"], 3)
                }
                for k, v in self.prompt_versions.items()
            }
        }

    def get_prompt_history(self, name: str) -> List[Dict[str, Any]]:
        """Get execution history for a specific prompt."""
        history = []
        for log in self.usage_logs:
            if log["prompt_key"].startswith(name):
                history.append(log)
        return history

    def compare_versions(self, name: str) -> Dict[str, Any]:
        """Compare all versions of a prompt."""
        versions = [k for k in self.prompt_versions.keys() if k.startswith(name)]

        comparison = {}
        for version in versions:
            data = self.prompt_versions[version]
            comparison[version] = {
                "usage_count": data["usage_count"],
                "avg_latency": round(data["avg_latency"], 3),
                "success_rate": round(data["success_rate"], 3),
                "created_at": data["created_at"].strftime("%Y-%m-%d %H:%M:%S")
            }

        return comparison

def demo_prompt_manager():
    """Demonstrate prompt management capabilities."""
    print("Production Prompt Management Demo")
    print("=" * 50)

    # Initialize manager
    pm = ProductionPromptManager()

    # Register multiple prompt versions
    print("\\n1. REGISTERING PROMPT VERSIONS")
    print("-" * 50)

    pm.register_prompt(
        "customer_email",
        "1.0",
        "Write a professional email response to: {complaint}\\nTone: {tone}",
        {"author": "team_a", "tested": True}
    )

    pm.register_prompt(
        "customer_email",
        "2.0",
        """You are a customer service representative.
Respond professionally to this complaint: {complaint}
Use a {tone} tone and include next steps.""",
        {"author": "team_b", "tested": True}
    )

    pm.register_prompt(
        "customer_email",
        "2.1",
        """You are an experienced customer service representative.
Customer complaint: {complaint}

Please respond with:
1. Acknowledgment of their concern
2. A {tone} response
3. Clear next steps
4. Contact information for follow-up""",
        {"author": "team_b", "tested": True, "improved": True}
    )

    print("Registered 3 versions of 'customer_email' prompt")

    # Execute prompts
    print("\\n2. EXECUTING PROMPTS")
    print("-" * 50)

    complaint = "My order hasn't arrived after 2 weeks"

    for version in ["1.0", "2.0", "2.1"]:
        result = pm.execute_prompt(
            "customer_email",
            version,
            {"complaint": complaint, "tone": "empathetic"},
            max_new_tokens=150
        )
        print(f"\\nVersion {version}:")
        print(f"Response: {result['response']}")
        print(f"Latency: {result['metrics']['latency']:.3f}s")

    # Simulate more usage for analytics
    print("\\n3. SIMULATING PRODUCTION USAGE")
    print("-" * 50)

    complaints = [
        "Product arrived damaged",
        "Wrong item received",
        "Refund not processed",
        "Account access issues"
    ]

    import random
    for _ in range(10):
        version = random.choice(["1.0", "2.0", "2.1"])
        complaint = random.choice(complaints)
        try:
            pm.execute_prompt(
                "customer_email",
                version,
                {"complaint": complaint, "tone": "professional"}
            )
        except:
            pass  # Simulate some failures

    # Get analytics
    print("\\n4. ANALYTICS REPORT")
    print("-" * 50)

    analytics = pm.get_analytics()
    print(f"Total prompts registered: {analytics['total_prompts']}")
    print(f"Total executions: {analytics['total_executions']}")
    print("\\nPerformance by version:")
    for version, metrics in analytics['prompt_performance'].items():
        print(f"\\n{version}:")
        print(f"  - Usage count: {metrics['usage_count']}")
        print(f"  - Avg latency: {metrics['avg_latency']}s")
        print(f"  - Success rate: {metrics['success_rate']}")

    # Get best performing version
    best = pm.get_best_prompt("customer_email")
    print(f"\\nBest performing version: {best}")

    # Compare versions
    print("\\n5. VERSION COMPARISON")
    print("-" * 50)

    comparison = pm.compare_versions("customer_email")
    for version, data in comparison.items():
        print(f"\\n{version}:")
        for key, value in data.items():
            print(f"  - {key}: {value}")

    # Additional prompt examples
    print("\\n6. ADDITIONAL PROMPT TYPES")
    print("-" * 50)

    # Register different prompt types
    pm.register_prompt(
        "product_description",
        "1.0",
        "Write a compelling product description for: {product}\\nKey features: {features}",
        {"type": "marketing"}
    )

    pm.register_prompt(
        "code_review",
        "1.0",
        "Review this code and provide feedback:\\n{code}\\nFocus on: {focus_areas}",
        {"type": "technical"}
    )

    pm.register_prompt(
        "meeting_summary",
        "1.0",
        "Summarize this meeting transcript:\\n{transcript}\\nHighlight: {key_points}",
        {"type": "business"}
    )

    print("Registered additional prompt types: product_description, code_review, meeting_summary")

    print("\\n" + "=" * 50)
    print("Prompt management demo completed!")

if __name__ == "__main__":
    demo_prompt_manager()

{
    "template": "The actual prompt text with {variables}",
    "metadata": {
        "author": "team_member_id",
        "tested": true,
        "test_results": {...},
        "approved_by": "reviewer_id"
    },
    "performance": {
        "avg_latency": 1.23,
        "success_rate": 0.95,
        "user_satisfaction": 0.87
    },
    "constraints": {
        "max_tokens": 1000,
        "temperature_range": [0.3, 0.7],
        "model_whitelist": ["gpt-4", "claude-2"]
    }
}

def route_request(user_id, prompt_name):
    # Consistent routing for user experience
    if user_id in beta_users:
        return get_latest_version(prompt_name)

    # Statistical significance testing
    if experiment_needs_more_data(prompt_name):
        return random_split(prompt_name)

    # Performance-based routing
    return get_best_performing_version(prompt_name)

def should_rollback(version_key, window_minutes=10):
    recent_metrics = get_recent_metrics(version_key, window_minutes)

    if recent_metrics['error_rate'] > 0.1:  # 10% errors
        return True, "High error rate"

    if recent_metrics['avg_latency'] > baseline * 2:  # 2x slower
        return True, "Performance degradation"

    if recent_metrics['user_complaints'] > threshold:
        return True, "User satisfaction drop"

    return False, None