Best Practices

def validate_prompt(user_input: str, max_length: int = 1000) -> str:
    # Limit length
    if len(user_input) > max_length:
        raise ValueError(f"Input too long: {len(user_input)} > {max_length}")
    
    # Remove potentially malicious content
    user_input = user_input.strip()
    
    # Check for prompt injection attempts
    suspicious_patterns = [
        "ignore previous instructions",
        "disregard all previous",
        "you are now",
        "new instructions:"
    ]
    
    for pattern in suspicious_patterns:
        if pattern.lower() in user_input.lower():
            raise ValueError("Potential prompt injection detected")
    
    return user_input

# Usage
try:
    safe_input = validate_prompt(user_input)
    response = client.chat.completions.create(
        model="llama-3.3-70b-versatile",
        messages=[{"role": "user", "content": safe_input}]
    )
except ValueError as e:
    print(f"Invalid input: {e}")

from flask import Flask, request
from flask_limiter import Limiter
from flask_limiter.util import get_remote_address

app = Flask(__name__)
limiter = Limiter(
    app=app,
    key_func=get_remote_address,
    default_limits=["100 per day", "10 per minute"]
)

@app.route("/api/chat", methods=["POST"])
@limiter.limit("5 per minute")
def chat():
    user_message = request.json.get("message")
    # Process with LLM API
    return {"response": "..."}

def select_model(task_type: str, complexity: str) -> dict:
    """Select optimal model and provider based on task"""
    
    if task_type == "code" and complexity == "simple":
        return {
            "provider": "openrouter",
            "model": "qwen/qwen3-coder:free",
            "reason": "Fast, free code model"
        }
    
    if task_type == "reasoning" and complexity == "complex":
        return {
            "provider": "cerebras",
            "model": "llama3.3-70b",
            "reason": "Large model with high daily limit"
        }
    
    # Default to fast, small model
    return {
        "provider": "groq",
        "model": "llama-3.1-8b-instant",
        "reason": "Ultra-fast for general tasks"
    }

from openai import OpenAI

client = OpenAI(
    base_url="https://api.groq.com/openai/v1",
    api_key=os.getenv("GROQ_API_KEY")
)

def stream_response(prompt: str):
    stream = client.chat.completions.create(
        model="llama-3.3-70b-versatile",
        messages=[{"role": "user", "content": prompt}],
        stream=True
    )
    
    for chunk in stream:
        if chunk.choices[0].delta.content:
            content = chunk.choices[0].delta.content
            print(content, end="", flush=True)

stream_response("Explain machine learning")

# ❌ Inefficient prompt
prompt = """
You are a highly knowledgeable and experienced assistant with extensive 
expertise in software development, computer science, and technology. 
Please provide a detailed, comprehensive, and well-structured explanation 
of the following topic, including examples, best practices, and any relevant 
considerations:

What is a REST API?
"""

# ✅ Efficient prompt
prompt = "Explain REST APIs concisely with an example."

# Both can produce similar quality responses, but the second uses ~90% fewer tokens

# ❌ Verbose system message
system = "You are an expert programmer with 20 years of experience..."

# ✅ Concise system message
system = "Expert programmer. Be concise."

def trim_conversation(messages: list, max_tokens: int = 2000) -> list:
    """Keep conversation under token limit while preserving context"""
    # Always keep system message
    system_msg = [m for m in messages if m["role"] == "system"]
    
    # Get recent messages
    other_msgs = [m for m in messages if m["role"] != "system"]
    
    # Estimate tokens (rough: 1 token ≈ 4 chars)
    total_chars = sum(len(m["content"]) for m in other_msgs)
    
    if total_chars > max_tokens * 4:
        # Keep last N messages to stay under limit
        keep_count = int(max_tokens * 4 / (total_chars / len(other_msgs)))
        other_msgs = other_msgs[-keep_count:]
    
    return system_msg + other_msgs

# Usage
full_conversation = [
    {"role": "system", "content": "Helpful assistant"},
    # ... 50 messages of conversation history ...
    {"role": "user", "content": "Current question"}
]

trimmed = trim_conversation(full_conversation, max_tokens=2000)

class SmartRouter:
    def __init__(self):
        self.groq_client = OpenAI(base_url="https://api.groq.com/openai/v1", api_key=os.getenv("GROQ_KEY"))
        self.cerebras_client = OpenAI(base_url="https://api.cerebras.ai/v1", api_key=os.getenv("CEREBRAS_KEY"))
    
    def route_request(self, messages: list):
        # Estimate complexity
        prompt = messages[-1]["content"]
        
        # Simple/short queries -> Groq (fastest)
        if len(prompt) < 100 and "?" in prompt:
            return self.groq_client.chat.completions.create(
                model="llama-3.1-8b-instant",
                messages=messages
            )
        
        # Complex queries -> Cerebras (larger model, higher limits)
        return self.cerebras_client.chat.completions.create(
            model="llama3.3-70b",
            messages=messages
        )

router = SmartRouter()
response = router.route_request([{"role": "user", "content": "Hi!"}])

from openai import OpenAI, APIError, RateLimitError, APIConnectionError
import logging

logger = logging.getLogger(__name__)

def safe_api_call(client, model, messages, max_retries=3):
    for attempt in range(max_retries):
        try:
            response = client.chat.completions.create(
                model=model,
                messages=messages
            )
            return response
            
        except RateLimitError as e:
            logger.warning(f"Rate limit hit on attempt {attempt + 1}: {e}")
            if attempt < max_retries - 1:
                time.sleep(2 ** attempt)  # Exponential backoff
            else:
                raise
        
        except APIConnectionError as e:
            logger.error(f"Connection error on attempt {attempt + 1}: {e}")
            if attempt < max_retries - 1:
                time.sleep(1)
            else:
                raise
        
        except APIError as e:
            logger.error(f"API error: {e}")
            raise  # Don't retry on API errors
        
        except Exception as e:
            logger.error(f"Unexpected error: {e}")
            raise

# Usage
try:
    response = safe_api_call(
        client,
        "llama-3.3-70b-versatile",
        [{"role": "user", "content": "Hello"}]
    )
except Exception as e:
    print(f"Failed after retries: {e}")

import time
from dataclasses import dataclass
from typing import List
import json

@dataclass
class APIMetrics:
    timestamp: float
    provider: str
    model: str
    tokens_used: int
    latency_ms: float
    success: bool
    error: str = None

class MetricsLogger:
    def __init__(self, log_file="api_metrics.jsonl"):
        self.log_file = log_file
    
    def log_call(self, metric: APIMetrics):
        with open(self.log_file, 'a') as f:
            f.write(json.dumps(metric.__dict__) + '\n')
    
    def get_daily_stats(self) -> dict:
        # Parse logs and compute stats
        with open(self.log_file, 'r') as f:
            metrics = [json.loads(line) for line in f]
        
        today_metrics = [
            m for m in metrics
            if time.time() - m['timestamp'] < 86400
        ]
        
        return {
            'total_requests': len(today_metrics),
            'total_tokens': sum(m['tokens_used'] for m in today_metrics),
            'avg_latency': sum(m['latency_ms'] for m in today_metrics) / len(today_metrics),
            'success_rate': sum(m['success'] for m in today_metrics) / len(today_metrics)
        }

logger = MetricsLogger()

# Log each API call
start = time.time()
try:
    response = client.chat.completions.create(...)
    logger.log_call(APIMetrics(
        timestamp=time.time(),
        provider='groq',
        model='llama-3.3-70b-versatile',
        tokens_used=response.usage.total_tokens,
        latency_ms=(time.time() - start) * 1000,
        success=True
    ))
except Exception as e:
    logger.log_call(APIMetrics(
        timestamp=time.time(),
        provider='groq',
        model='llama-3.3-70b-versatile',
        tokens_used=0,
        latency_ms=(time.time() - start) * 1000,
        success=False,
        error=str(e)
    ))