Prompt Operations

// Register a new prompt template
const promptRegistry = await ants.llmops.promptRegistry
 
const prompt = await promptRegistry.register({
  name: 'customer-support-classifier',
  version: '1.2.0',
  category: 'classification',
  template: `
You are a customer support AI assistant. Classify the following customer message into one of these categories:
 
Categories:
- billing: Questions about charges, payments, refunds
- technical: Technical issues, bugs, feature requests
- general: General questions, account information
- complaint: Complaints, dissatisfaction
 
Customer message: {{customer_message}}
 
Respond with only the category name and a brief explanation.
`,
  variables: ['customer_message'],
  metadata: {
    useCase: 'customer-support',
    model: 'gpt-4',
    expectedOutput: 'category',
    performance: {
      accuracy: 0.94,
      avgTokens: 45
    }
  }
})
 
console.log(`Prompt registered: ${prompt.id}`)

# Create new prompt version
prompt_registry = ants.llmops.prompt_registry
 
# Update existing prompt
new_version = prompt_registry.create_version(
    prompt_id='customer-support-classifier',
    version='1.3.0',
    changes='Added urgency detection and improved accuracy',
    template='''
You are a customer support AI assistant. Classify the following customer message:
 
Categories:
- billing: Questions about charges, payments, refunds
- technical: Technical issues, bugs, feature requests  
- general: General questions, account information
- complaint: Complaints, dissatisfaction
- urgent: High priority issues requiring immediate attention
 
Customer message: {{customer_message}}
 
First, determine if this is urgent (contains words like "urgent", "asap", "emergency", "critical").
Then classify into the appropriate category.
 
Format: [URGENT/NORMAL] category: explanation
''',
    variables=['customer_message']
)
 
print(f"New version created: {new_version.version}")

// Create comprehensive test suite for prompts
const testSuite = await ants.llmops.createPromptTestSuite({
  promptId: 'customer-support-classifier',
  tests: [
    {
      name: 'accuracy-test',
      testCases: [
        {
          input: { customer_message: 'I was charged twice for my subscription' },
          expectedCategory: 'billing',
          expectedUrgency: 'NORMAL'
        },
        {
          input: { customer_message: 'URGENT: My app crashed and I lost all my data!' },
          expectedCategory: 'technical',
          expectedUrgency: 'URGENT'
        }
      ],
      metrics: ['accuracy', 'precision', 'recall']
    },
    {
      name: 'cost-test',
      scenarios: [
        'simple-queries',
        'complex-queries',
        'edge-cases'
      ],
      maxTokensPerQuery: 100,
      maxCostPerQuery: 0.005
    },
    {
      name: 'consistency-test',
      iterations: 10,
      sameInput: 'I need help with my account',
      expectedConsistency: 0.95
    }
  ]
})
 
const results = await testSuite.run()
console.log('Test Results:', results.summary)

# Monitor prompt performance in production
performance = ants.llmops.get_prompt_performance({
    'prompt_id': 'customer-support-classifier',
    'time_range': 'last_7_days',
    'metrics': [
        'accuracy',
        'avg_tokens',
        'avg_cost',
        'response_time',
        'user_satisfaction'
    ]
})
 
print("Prompt Performance:")
print(f"Accuracy: {performance.accuracy:.2%}")
print(f"Avg Tokens: {performance.avg_tokens}")
print(f"Avg Cost: ${performance.avg_cost:.4f}")
print(f"Response Time: {performance.response_time}ms")
print(f"User Satisfaction: {performance.user_satisfaction:.1%}")

// Optimize prompts for token efficiency
const optimizer = await ants.llmops.createPromptOptimizer({
  promptId: 'customer-support-classifier',
  optimizationGoals: [
    'reduce_tokens',
    'maintain_accuracy',
    'improve_clarity'
  ],
  constraints: {
    minAccuracy: 0.90,
    maxTokens: 80
  }
})
 
const optimizedPrompt = await optimizer.optimize({
  techniques: [
    'template_compression',
    'synonym_replacement',
    'instruction_clarification'
  ],
  iterations: 5
})
 
console.log('Optimization Results:')
console.log(`Original tokens: ${optimizedPrompt.original.tokens}`)
console.log(`Optimized tokens: ${optimizedPrompt.optimized.tokens}`)
console.log(`Token reduction: ${optimizedPrompt.reduction}%`)
console.log(`Accuracy maintained: ${optimizedPrompt.accuracyMaintained}`)

# A/B test different prompt versions
ab_test = ants.llmops.create_prompt_ab_test({
    'name': 'classifier-prompt-comparison',
    'variants': [
        {
            'name': 'current',
            'prompt_id': 'customer-support-classifier',
            'version': '1.2.0',
            'traffic_percentage': 50
        },
        {
            'name': 'optimized',
            'prompt_id': 'customer-support-classifier',
            'version': '1.3.0',
            'traffic_percentage': 50
        }
    ],
    'metrics': ['accuracy', 'avg_tokens', 'user_satisfaction'],
    'duration': '2_weeks',
    'statistical_significance': 0.95
})
 
results = ab_test.get_results()
print("A/B Test Results:")
print(f"Winner: {results.winner}")
print(f"Confidence: {results.confidence:.2%}")
print(f"Improvement: {results.improvement:.1%}")

// Create reusable prompt templates
const templateManager = await ants.llmops.templateManager
 
const baseTemplate = await templateManager.createTemplate({
  name: 'classification-template',
  description: 'Generic classification template',
  template: `
You are an AI assistant. Classify the following {{input_type}} into one of these categories:
 
Categories:
{{categories}}
 
{{input_type}}: {{input_value}}
 
Respond with only the category name and a brief explanation.
`,
  variables: ['input_type', 'categories', 'input_value'],
  tags: ['classification', 'generic']
})
 
// Use template for specific use cases
const customerSupportPrompt = await templateManager.createFromTemplate({
  templateId: 'classification-template',
  name: 'customer-support-classifier',
  variables: {
    input_type: 'customer message',
    categories: `- billing: Questions about charges, payments, refunds
- technical: Technical issues, bugs, feature requests
- general: General questions, account information
- complaint: Complaints, dissatisfaction`,
    input_value: '{{customer_message}}'
  }
})

# Generate prompts dynamically based on context
prompt_generator = ants.llmops.prompt_generator
 
# Generate context-aware prompts
dynamic_prompt = prompt_generator.generate({
    'base_template': 'customer-support-classifier',
    'context': {
        'user_tier': 'premium',
        'previous_interactions': 3,
        'time_of_day': 'business_hours',
        'language': 'en'
    },
    'customizations': {
        'tone': 'professional',
        'detail_level': 'high',
        'include_examples': True
    }
})
 
print(f"Generated prompt: {dynamic_prompt.template}")
print(f"Variables: {dynamic_prompt.variables}")

// Implement prompt security guardrails
const securityManager = await ants.llmops.securityManager
 
const guardrails = await securityManager.createPromptGuardrails({
  promptId: 'customer-support-classifier',
  rules: [
    {
      type: 'content_filter',
      action: 'block',
      patterns: ['inappropriate_content', 'spam', 'abuse']
    },
    {
      type: 'pii_detection',
      action: 'redact',
      fields: ['email', 'phone', 'ssn']
    },
    {
      type: 'bias_detection',
      action: 'flag',
      categories: ['gender', 'race', 'age']
    }
  ]
})
 
// Test prompt with guardrails
const testResult = await guardrails.testPrompt({
  input: 'My email is john@example.com and I need help',
  expectedAction: 'redact_pii'
})
 
console.log('Security test result:', testResult)

# Audit prompts for compliance
audit_report = ants.llmops.audit_prompts({
    'prompt_ids': ['customer-support-classifier', 'billing-assistant'],
    'compliance_frameworks': ['gdpr', 'ccpa', 'sox'],
    'checks': [
        'pii_handling',
        'bias_detection',
        'accessibility',
        'data_retention'
    ]
})
 
print("Compliance Audit Results:")
for prompt_id, results in audit_report.items():
    print(f"\n{prompt_id}:")
    print(f"  Overall Score: {results.overall_score}/100")
    print(f"  Issues: {len(results.issues)}")
    for issue in results.issues:
        print(f"    - {issue.severity}: {issue.description}")

// Analyze prompt usage patterns
const analytics = await ants.llmops.getPromptAnalytics({
  promptId: 'customer-support-classifier',
  timeRange: 'last_30_days',
  dimensions: [
    'usage_by_hour',
    'usage_by_category',
    'performance_by_input_type',
    'cost_trends'
  ]
})
 
console.log('Prompt Analytics:')
console.log(`Total queries: ${analytics.totalQueries}`)
console.log(`Peak usage hour: ${analytics.peakHour}`)
console.log(`Most common category: ${analytics.mostCommonCategory}`)
console.log(`Cost trend: ${analytics.costTrend}`)

# Get performance insights and recommendations
insights = ants.llmops.get_prompt_insights({
    'prompt_id': 'customer-support-classifier',
    'analysis_period': 'last_7_days'
})
 
print("Performance Insights:")
for insight in insights.recommendations:
    print(f"- {insight.type}: {insight.description}")
    print(f"  Impact: {insight.impact}")
    print(f"  Effort: {insight.effort}")