SDK Integration

pip install handit

from handit import HanditTracker
 
# Initialize the tracker (same as for tracing)
tracker = HanditTracker(
    api_key="your-api-key",
    project_id="your-project"
)

npm install @handit/sdk
# or
yarn add @handit/sdk

import { HanditClient } from '@handit/sdk';
 
// Initialize the client (same as for tracing)
const handit = new HanditClient({
  apiKey: 'your-api-key',
  projectId: 'your-project'
});

def fetch_optimized_prompt(model_id: str) -> str:
    """
    Fetch the latest optimized prompt for the given model ID.
    
    Args:
        model_id (str): The slug/ID of the LLM node (e.g., "customer-support-llm")
        
    Returns:
        str: The optimized prompt text
        
    Raises:
        OptimizationError: If no optimization is available
        NetworkError: If unable to connect to the service
    """

async function fetchOptimizedPrompt({ modelId }) {
  /**
   * Fetch the latest optimized prompt for the given model ID.
   * 
   * @param {Object} params - Parameters object
   * @param {string} params.modelId - The slug/ID of the LLM node
   * @returns {Promise<string>} The optimized prompt text
   * @throws {OptimizationError} If no optimization is available
   */
}

from handit import HanditTracker
import openai
 
# Initialize Handit tracker
tracker = HanditTracker(api_key="your-api-key", project_id="your-project")
 
def generate_customer_response(user_query: str, context: dict = None) -> str:
    """Generate customer service response with optimized prompt."""
    
    # Fetch the latest optimized prompt
    try:
        system_prompt = tracker.fetch_optimized_prompt("customer-support-llm")
        print("Using optimized prompt")
    except Exception as e:
        # Fallback to default prompt
        system_prompt = """You are a helpful customer service assistant. 
        Respond to customer inquiries with accurate information and clear solutions.
        Always be professional and empathetic."""
        print(f"Using fallback prompt: {e}")
    
    # Use with your LLM
    response = openai.chat.completions.create(
        model="gpt-4",
        messages=[
            {"role": "system", "content": system_prompt},
            {"role": "user", "content": user_query}
        ],
        temperature=0.7
    )
    
    return response.choices[0].message.content
 
# Usage
customer_query = "I'm having trouble with my order delivery"
response = generate_customer_response(customer_query)
print(response)

import { HanditClient } from '@handit/sdk';
import OpenAI from 'openai';
 
// Initialize clients
const handit = new HanditClient({ 
  apiKey: 'your-api-key',
  projectId: 'your-project' 
});
 
const openai = new OpenAI({ apiKey: 'your-openai-key' });
 
async function generateCustomerResponse(userQuery, context = {}) {
  // Fetch the latest optimized prompt
  let systemPrompt;
  try {
    systemPrompt = await handit.fetchOptimizedPrompt({ 
      modelId: 'customer-support-llm' 
    });
    console.log('Using optimized prompt');
  } catch (error) {
    // Fallback to default prompt
    systemPrompt = `You are a helpful customer service assistant. 
    Respond to customer inquiries with accurate information and clear solutions.
    Always be professional and empathetic.`;
    console.warn('Using fallback prompt:', error.message);
  }
  
  // Use with your LLM
  const response = await openai.chat.completions.create({
    model: 'gpt-4',
    messages: [
      { role: 'system', content: systemPrompt },
      { role: 'user', content: userQuery }
    ],
    temperature: 0.7
  });
  
  return response.choices[0].message.content;
}
 
// Usage
const customerQuery = "I'm having trouble with my order delivery";
const response = await generateCustomerResponse(customerQuery);
console.log(response);

from handit import HanditTracker, OptimizationError
import logging
import time
from functools import lru_cache
from typing import Optional, Dict, Any
 
class OptimizedPromptManager:
    """Production-ready prompt management with caching and error handling."""
    
    def __init__(self, api_key: str, project_id: str):
        self.tracker = HanditTracker(api_key=api_key, project_id=project_id)
        self.logger = logging.getLogger(__name__)
        self.default_prompts = {}
        self._cache_ttl = 300  # 5 minutes
        
    def set_default_prompt(self, model_id: str, prompt: str):
        """Set fallback prompt for a model."""
        self.default_prompts[model_id] = prompt
        
    @lru_cache(maxsize=128)
    def _get_cached_prompt(self, model_id: str, cache_key: str) -> str:
        """Internal cached prompt fetching."""
        return self.tracker.fetch_optimized_prompt(model_id=model_id)
    
    def get_optimized_prompt(self, model_id: str) -> tuple[str, bool]:
        """
        Get optimized prompt with caching and fallback.
        
        Returns:
            tuple: (prompt_text, is_optimized)
        """
        # Create cache key with TTL
        cache_key = f"{model_id}_{int(time.time() // self._cache_ttl)}"
        
        try:
            prompt = self._get_cached_prompt(model_id, cache_key)
            self.logger.info(f"Using optimized prompt for {model_id}")
            return prompt, True
            
        except OptimizationError.NotFound:
            self.logger.info(f"No optimization available for {model_id}")
            return self._get_fallback_prompt(model_id), False
            
        except OptimizationError.NetworkError:
            self.logger.warning(f"Network error fetching optimization for {model_id}")
            return self._get_fallback_prompt(model_id), False
            
        except Exception as e:
            self.logger.error(f"Unexpected error: {e}")
            return self._get_fallback_prompt(model_id), False
    
    def _get_fallback_prompt(self, model_id: str) -> str:
        """Get fallback prompt for model."""
        return self.default_prompts.get(
            model_id, 
            "You are a helpful AI assistant."
        )
 
# Usage example
prompt_manager = OptimizedPromptManager(
    api_key="your-api-key",
    project_id="your-project"
)
 
# Set fallback prompts
prompt_manager.set_default_prompt(
    "customer-support-llm",
    "You are a helpful customer service assistant..."
)
 
def generate_response(model_id: str, user_query: str) -> str:
    # Get optimized prompt
    prompt, is_optimized = prompt_manager.get_optimized_prompt(model_id)
    
    # Generate response with optimized prompt
    response = openai.chat.completions.create(
        model="gpt-4",
        messages=[
            {"role": "system", "content": prompt},
            {"role": "user", "content": user_query}
        ]
    )
    
    return response.choices[0].message.content

import { HanditClient } from '@handit/sdk';
 
class OptimizedPromptManager {
  constructor(apiKey, projectId) {
    this.handit = new HanditClient({ apiKey, projectId });
    this.cache = new Map();
    this.cacheTTL = 5 * 60 * 1000; // 5 minutes
    this.defaultPrompts = new Map();
  }
  
  setDefaultPrompt(modelId, prompt) {
    this.defaultPrompts.set(modelId, prompt);
  }
  
  async getCachedPrompt(modelId) {
    const cacheKey = `${modelId}_${Math.floor(Date.now() / this.cacheTTL)}`;
    
    if (this.cache.has(cacheKey)) {
      return this.cache.get(cacheKey);
    }
    
    try {
      const prompt = await this.handit.fetchOptimizedPrompt({ modelId });
      this.cache.set(cacheKey, { prompt, isOptimized: true });
      
      // Clean old cache entries
      setTimeout(() => this.cache.delete(cacheKey), this.cacheTTL);
      
      return { prompt, isOptimized: true };
    } catch (error) {
      const fallback = this.getFallbackPrompt(modelId);
      this.cache.set(cacheKey, { prompt: fallback, isOptimized: false });
      return { prompt: fallback, isOptimized: false };
    }
  }
  
  getFallbackPrompt(modelId) {
    return this.defaultPrompts.get(modelId) || 'You are a helpful AI assistant.';
  }
}
 
// Usage example
const promptManager = new OptimizedPromptManager('api-key', 'project-id');
 
// Set fallback prompts
promptManager.setDefaultPrompt(
  'customer-support-llm',
  'You are a helpful customer service assistant...'
);
 
async function generateResponse(modelId, userQuery) {
  // Get optimized prompt
  const { prompt, isOptimized } = await promptManager.getCachedPrompt(modelId);
  
  // Generate response with optimized prompt
  const response = await openai.chat.completions.create({
    model: 'gpt-4',
    messages: [
      { role: 'system', content: prompt },
      { role: 'user', content: userQuery }
    ]
  });
  
  return response.choices[0].message.content;
}