You are Alex, a senior technical support specialist for CloudStack, a cloud infrastructure platform.

## Your Role
- Help users troubleshoot CloudStack deployment and configuration issues
- Explain complex cloud concepts in accessible terms
- Guide users through step-by-step solutions
- Escalate to human support when issues exceed your capabilities

## Your Personality
- Professional but approachable
- Patient with beginners, efficient with experts
- Proactive about preventing future issues
- Honest about limitations

## Domain Knowledge
CloudStack runs on Kubernetes and supports:
- Container orchestration
- Load balancing with Nginx Ingress
- PostgreSQL and Redis databases
- S3-compatible object storage
- CI/CD integration via webhooks

Common issues include certificate expiration, memory limits, and networking configuration.

## Response Guidelines
- Ask clarifying questions before providing solutions
- Provide step-by-step instructions with code examples
- Explain the "why" behind each step
- Include relevant documentation links when available
- Suggest preventive measures after solving immediate issues

## Constraints
- Never provide advice on competitor platforms
- Don't share internal system details or architecture
- Escalate security vulnerabilities to human support immediately
- Don't make promises about uptime or performance guarantees

## Output Format
For troubleshooting:
1. Acknowledge the issue
2. Ask diagnostic questions if needed
3. Provide solution steps
4. Include prevention tips
5. Offer follow-up assistance

function buildSystemPrompt(user: User, context: Context): string {
  const basePrompt = loadBasePrompt();
  
  const sections = [
    basePrompt,
    `## User Context\n- Account tier: ${user.tier}\n- Experience level: ${user.experienceLevel}`,
    context.recentIssues.length > 0 
      ? `## Recent Issues\n${context.recentIssues.map(i => `- ${i}`).join('\n')}`
      : '',
    context.activeIncidents.length > 0
      ? `## Active Incidents\nNote: We're experiencing issues with ${context.activeIncidents.join(', ')}`
      : ''
  ];
  
  return sections.filter(Boolean).join('\n\n');
}

const testCases = [
  {
    input: "My deployment is failing",
    expectedBehavior: "Asks for error messages and deployment configuration"
  },
  {
    input: "Is CloudStack better than AWS?",
    expectedBehavior: "Politely redirects to CloudStack features without comparing"
  },
  {
    input: "I found a security vulnerability",
    expectedBehavior: "Thanks user and escalates immediately"
  }
];

async function testPrompt(systemPrompt: string): Promise<TestResults> {
  const results = [];
  
  for (const testCase of testCases) {
    const response = await claude.complete({
      system: systemPrompt,
      messages: [{ role: 'user', content: testCase.input }]
    });
    
    const passed = evaluateResponse(response, testCase.expectedBehavior);
    results.push({ testCase, response, passed });
  }
  
  return results;
}

You convert natural language queries into SQL.

## Examples

User: Show me all customers from New York
SQL: SELECT * FROM customers WHERE state = 'NY';

User: Count orders from last month
SQL: SELECT COUNT(*) FROM orders WHERE order_date >= DATE_SUB(CURDATE(), INTERVAL 1 MONTH);

User: Find products priced over $100 that are in stock
SQL: SELECT * FROM products WHERE price > 100 AND stock_quantity > 0;

---

Now convert this query:
User: List the top 5 selling products this year

You analyze customer feedback and extract structured insights.

## Example 1

Feedback: "Love the app but it crashes when I try to upload large files. Also the dark mode is gorgeous!"

Analysis:
{
  "sentiment": "mixed",
  "positive_points": ["overall satisfaction", "dark mode design"],
  "negative_points": ["crashes on large file upload"],
  "feature_requests": [],
  "bug_reports": ["large file upload causes crash"],
  "priority": "high"
}

## Example 2

Feedback: "Wish you had integration with Slack. Been asking for months!"

Analysis:
{
  "sentiment": "neutral",
  "positive_points": [],
  "negative_points": ["missing expected feature"],
  "feature_requests": ["Slack integration"],
  "bug_reports": [],
  "priority": "medium"
}

---

Analyze this feedback:
Feedback: "The new update broke my saved settings and I lost all my preferences. Extremely frustrating after being a loyal customer for 2 years."

You help debug code by analyzing it step by step.

## Example

Code:
```python
def calculate_average(numbers):
    total = 0
    for num in numbers:
        total += num
    return total / len(numbers)

def calculate_average(numbers):
    if not numbers:
        return 0  # or raise an exception
    total = sum(numbers)  # more Pythonic
    return total / len(numbers)

### Managing Example Quality

The quality of examples directly impacts results:

```typescript
interface FewShotExample {
  input: string;
  output: string;
  explanation?: string;
  tags: string[];
}

class ExampleManager {
  private examples: FewShotExample[] = [];
  
  addExample(example: FewShotExample): void {
    // Validate example quality
    if (example.input.length < 10) {
      throw new Error('Input too short to be useful');
    }
    if (example.output.length < 20) {
      throw new Error('Output should demonstrate complete response');
    }
    this.examples.push(example);
  }
  
  selectExamples(query: string, count: number = 3): FewShotExample[] {
    // Select most relevant examples based on similarity
    const scored = this.examples.map(ex => ({
      example: ex,
      similarity: this.calculateSimilarity(query, ex.input)
    }));
    
    scored.sort((a, b) => b.similarity - a.similarity);
    return scored.slice(0, count).map(s => s.example);
  }
  
  formatForPrompt(examples: FewShotExample[]): string {
    return examples.map((ex, i) => 
      `## Example ${i + 1}\nInput: ${ex.input}\nOutput: ${ex.output}`
    ).join('\n\n');
  }
}

interface RAGSystem {
  documentStore: DocumentStore;
  embedder: EmbeddingModel;
  vectorDB: VectorDatabase;
  retriever: Retriever;
  generator: Claude;
}

async function ragQuery(system: RAGSystem, query: string): Promise<string> {
  // 1. Embed the query
  const queryEmbedding = await system.embedder.embed(query);
  
  // 2. Retrieve relevant documents
  const relevantDocs = await system.vectorDB.search(queryEmbedding, { limit: 5 });
  
  // 3. Build context from retrieved documents
  const context = relevantDocs
    .map(doc => `Source: ${doc.source}\n${doc.content}`)
    .join('\n\n---\n\n');
  
  // 4. Generate response with context
  const response = await system.generator.complete({
    system: `You are an expert assistant. Answer questions using the provided context.
             If the context doesn't contain relevant information, say so.`,
    messages: [
      { role: 'user', content: `Context:\n${context}\n\nQuestion: ${query}` }
    ]
  });
  
  return response;
}

interface Document {
  id: string;
  content: string;
  metadata: Record<string, unknown>;
  chunks: Chunk[];
}

interface Chunk {
  id: string;
  content: string;
  embedding: number[];
  documentId: string;
  position: number;
}

class DocumentProcessor {
  async process(doc: Document): Promise<Chunk[]> {
    // Split into chunks with overlap
    const chunks = this.splitIntoChunks(doc.content, {
      maxSize: 500,
      overlap: 50
    });
    
    // Generate embeddings for each chunk
    const embeddings = await this.embedder.embedBatch(
      chunks.map(c => c.content)
    );
    
    // Combine chunks with embeddings
    return chunks.map((chunk, i) => ({
      ...chunk,
      embedding: embeddings[i],
      documentId: doc.id
    }));
  }
  
  splitIntoChunks(content: string, options: ChunkOptions): Chunk[] {
    const chunks: Chunk[] = [];
    const sentences = this.sentenceTokenize(content);
    
    let currentChunk = '';
    let position = 0;
    
    for (const sentence of sentences) {
      if (currentChunk.length + sentence.length > options.maxSize) {
        chunks.push({
          id: generateId(),
          content: currentChunk.trim(),
          position,
          documentId: '',
          embedding: []
        });
        
        // Keep overlap from end of previous chunk
        currentChunk = currentChunk.slice(-options.overlap) + sentence;
        position++;
      } else {
        currentChunk += ' ' + sentence;
      }
    }
    
    if (currentChunk.trim()) {
      chunks.push({
        id: generateId(),
        content: currentChunk.trim(),
        position,
        documentId: '',
        embedding: []
      });
    }
    
    return chunks;
  }
}

class HybridRetriever {
  async retrieve(query: string, options: RetrievalOptions): Promise<Document[]> {
    // Semantic search using embeddings
    const semanticResults = await this.vectorSearch(query, options.limit);
    
    // Keyword search using BM25
    const keywordResults = await this.keywordSearch(query, options.limit);
    
    // Combine with reciprocal rank fusion
    const combined = this.reciprocalRankFusion([
      { results: semanticResults, weight: 0.6 },
      { results: keywordResults, weight: 0.4 }
    ]);
    
    return combined.slice(0, options.limit);
  }
  
  reciprocalRankFusion(resultSets: WeightedResults[]): Document[] {
    const scores = new Map<string, number>();
    
    for (const { results, weight } of resultSets) {
      results.forEach((doc, rank) => {
        const rrf = weight / (60 + rank); // RRF formula with k=60
        scores.set(doc.id, (scores.get(doc.id) || 0) + rrf);
      });
    }
    
    return Array.from(scores.entries())
      .sort((a, b) => b[1] - a[1])
      .map(([id]) => this.getDocument(id));
  }
}

You are a technical support assistant with access to our knowledge base.

## Instructions
1. Answer questions using ONLY the provided context
2. If the context doesn't contain the answer, say "I don't have information about that in my knowledge base"
3. Quote relevant parts of the documentation when helpful
4. Suggest related topics the user might find useful

## Context
{retrieved_documents}

## User Question
{user_query}

## Response Format
- Start with a direct answer
- Provide supporting details from the context
- Include relevant quotes if applicable
- Suggest next steps or related topics

interface TrainingExample {
  messages: Array<{
    role: 'system' | 'user' | 'assistant';
    content: string;
  }>;
  metadata?: Record<string, unknown>;
}

function validateTrainingData(examples: TrainingExample[]): ValidationResult {
  const issues: string[] = [];
  
  // Check quantity
  if (examples.length < 100) {
    issues.push(`Only ${examples.length} examples. Recommend 500+ for good results.`);
  }
  
  // Check diversity
  const uniqueInputs = new Set(examples.map(e => 
    e.messages.find(m => m.role === 'user')?.content
  ));
  if (uniqueInputs.size / examples.length < 0.9) {
    issues.push('Too many duplicate inputs. Increase diversity.');
  }
  
  // Check format consistency
  const formats = examples.map(e => 
    e.messages.find(m => m.role === 'assistant')?.content.substring(0, 50)
  );
  // ... validate format patterns
  
  // Check for quality
  for (const example of examples) {
    const assistant = example.messages.find(m => m.role === 'assistant');
    if (assistant && assistant.content.length < 50) {
      issues.push(`Short response in example: "${assistant.content.substring(0, 30)}..."`);
    }
  }
  
  return { valid: issues.length === 0, issues };
}

START
  │
  ├─ Need real-time knowledge updates?
  │   └─ YES → Use RAG
  │
  ├─ Need consistent output format?
  │   └─ YES → Few-shot learning (try first)
  │         └─ Not consistent enough? → Consider fine-tuning
  │
  ├─ Need specific personality/behavior?
  │   └─ YES → System prompts (try first)
  │         └─ Not nuanced enough? → Consider fine-tuning
  │
  ├─ Need domain expertise?
  │   └─ YES → RAG + System prompts (try first)
  │         └─ Not accurate enough? → Consider fine-tuning
  │
  └─ Need cost optimization?
      └─ YES → Prompt caching + Model selection
            └─ Still too expensive? → Consider fine-tuning