Simple LLM Integration

import os
import time
from noveum_trace import trace_llm, trace_operation
import openai
import noveum_trace
 
# Initialize Noveum (add this once at the start of your app)
noveum_trace.init(
    api_key=os.getenv("NOVEUM_API_KEY"),
    project="customer-support-bot",
    environment="development"
)
 
def customer_support_bot(user_question: str, customer_id: str = None):
    """
    A simple customer support chatbot that traces LLM calls
    """
    
    # Create a trace for the entire customer interaction
    with trace_operation("customer-support-query") as main_span:
        # Add customer context
        main_span.set_attributes({
            "customer.id": customer_id or "anonymous",
            "query.length": len(user_question),
            "query.type": "customer_support",
            "bot.version": "1.0.0"
        })
        
        # Add start event
        main_span.add_event("customer.query.received", {
            "timestamp": time.time(),
            "query.preview": user_question[:50] + "..." if len(user_question) > 50 else user_question
        })
        
        try:
            # Trace the LLM call
            with trace_llm(model="gpt-4", provider="openai") as llm_span:
                # Add LLM-specific attributes
                llm_span.set_attributes({
                    "ai.model": "gpt-4",
                    "ai.provider": "openai",
                    "ai.temperature": 0.7,
                    "ai.max_tokens": 1000
                })
                
                # Add LLM start event
                llm_span.add_event("ai.completion.started", {
                    "timestamp": time.time(),
                    "prompt.length": len(user_question)
                })
                
                # Make the LLM call
                response = openai.chat.completions.create(
                    model="gpt-4",
                    messages=[
                        {
                            "role": "system", 
                            "content": "You are a helpful customer support assistant. Answer questions clearly and concisely."
                        },
                        {"role": "user", "content": user_question}
                    ],
                    temperature=0.7,
                    max_tokens=1000
                )
                
                # Extract the response
                ai_response = response.choices[0].message.content
                
                # Set usage attributes for cost tracking
                llm_span.set_usage_attributes(
                    input_tokens=response.usage.prompt_tokens,
                    output_tokens=response.usage.completion_tokens
                )
                
                # Add completion event
                llm_span.add_event("ai.completion.finished", {
                    "timestamp": time.time(),
                    "response.length": len(ai_response),
                    "tokens.used": response.usage.total_tokens,
                    "finish.reason": response.choices[0].finish_reason
                })
                
                # Add response attributes
                llm_span.set_attributes({
                    "response.length": len(ai_response),
                    "response.quality": "high" if len(ai_response) > 50 else "low",
                    "cost.usd": response.usage.total_tokens * 0.00003  # Approximate cost
                })
            
            # Add success event
            main_span.add_event("customer.query.answered", {
                "timestamp": time.time(),
                "response.length": len(ai_response),
                "success": True
            })
            
            # Set final status
            main_span.set_status("success")
            
            return ai_response
            
        except Exception as e:
            # Add error event
            main_span.add_event("customer.query.failed", {
                "timestamp": time.time(),
                "error.type": type(e).__name__,
                "error.message": str(e)
            })
            
            # Set error status
            main_span.set_status("error", str(e))
            
            # Return fallback response
            return "I'm sorry, I'm having trouble processing your request right now. Please try again later."
 
# Example usage
if __name__ == "__main__":
    # Set your OpenAI API key
    openai.api_key = os.getenv("OPENAI_API_KEY")
    
    # Example questions
    questions = [
        "How do I reset my password?",
        "What are your business hours?",
        "Can I cancel my subscription?",
        "How do I contact support?"
    ]
    
    # Process each question
    for i, question in enumerate(questions, 1):
        print(f"\n--- Question {i} ---")
        print(f"User: {question}")
        
        response = customer_support_bot(
            user_question=question,
            customer_id=f"cust_{i:03d}"
        )
        
        print(f"Bot: {response}")
        print("-" * 50)

--- Question 1 ---
User: How do I reset my password?
Bot: To reset your password, please follow these steps:
1. Go to the login page
2. Click "Forgot Password"
3. Enter your email address
4. Check your email for reset instructions
5. Follow the link to create a new password

If you need further assistance, please contact our support team.
--------------------------------------------------

--- Question 2 ---
User: What are your business hours?
Bot: Our business hours are:
- Monday to Friday: 9:00 AM - 6:00 PM EST
- Saturday: 10:00 AM - 4:00 PM EST
- Sunday: Closed

For urgent matters outside business hours, please email us and we'll respond as soon as possible.
--------------------------------------------------

customer-support-query (2.3s)
├── gpt-4 (1.8s)
    ├── ai.completion.started
    ├── ai.completion.finished
    └── customer.query.answered

# Add customer tier and region
main_span.set_attributes({
    "customer.id": customer_id,
    "customer.tier": "premium",
    "customer.region": "us-west",
    "query.language": "en",
    "query.sentiment": "neutral"
})

# Add quality metrics
llm_span.set_attributes({
    "response.quality_score": calculate_quality_score(ai_response),
    "response.relevance_score": calculate_relevance_score(question, ai_response),
    "response.helpfulness_score": calculate_helpfulness_score(ai_response)
})

# Track business KPIs
main_span.set_attributes({
    "business.metric.resolution_time": time.time() - start_time,
    "business.metric.customer_satisfaction": "high",
    "business.metric.escalation_needed": False
})

# Make sure your environment variables are set
export NOVEUM_API_KEY="your-noveum-key"
export OPENAI_API_KEY="your-openai-key"