Reliable LLM

ReliableLLM provides automatic failover between primary and secondary LLM providers, ensuring your application stays operational even when one provider fails.

Why Use ReliableLLM?

LLM APIs can fail for various reasons: rate limits, network issues, temporary outages, or service disruptions. ReliableLLM automatically handles these scenarios by failing over to a backup provider, ensuring your application remains resilient.

How It Works

ReliableLLM implements a simple yet effective failover pattern:

Basic Usage

Creating a ReliableLLM instance is straightforward - you just need two LLM providers:

from SimplerLLM.language.llm import LLM, LLMProvider
from SimplerLLM.language.llm.reliable import ReliableLLM

# Create primary and secondary LLM instances
primary_llm = LLM.create(
    provider=LLMProvider.OPENAI,
    model_name="gpt-4o"
)

secondary_llm = LLM.create(
    provider=LLMProvider.ANTHROPIC,
    model_name="claude-3-5-sonnet-20241022"
)

# Create ReliableLLM with automatic failover
reliable_llm = ReliableLLM(primary_llm, secondary_llm)

# Generate response - automatically fails over if needed
response = reliable_llm.generate_response(
    prompt="Explain machine learning in simple terms"
)

print(response)

Configuration Options

ReliableLLM supports several configuration options to customize its behavior:

With Retry Configuration

reliable_llm = ReliableLLM(
    primary_llm,
    secondary_llm,
    max_retries=3,           # Number of retry attempts
    initial_delay=1.0,       # Initial delay between retries (seconds)
    exponential_base=2.0     # Exponential backoff multiplier
)

With Validation

# Validate both providers during initialization
reliable_llm = ReliableLLM(
    primary_llm,
    secondary_llm,
    validate_on_init=True    # Test both providers at creation time
)

Advanced Usage

Getting Provider Information

ReliableLLM returns metadata about which provider was used:

response, provider_used, model_used = reliable_llm.generate_response(
    prompt="What is quantum computing?",
    return_metadata=True
)

print(f"Response: {response}")
print(f"Provider: {provider_used.name}")  # e.g., "OPENAI"
print(f"Model: {model_used}")              # e.g., "gpt-4o"

Multiple Failover Providers

You can chain multiple ReliableLLM instances for multi-level failover:

# Create three different providers
openai_llm = LLM.create(provider=LLMProvider.OPENAI, model_name="gpt-4o")
anthropic_llm = LLM.create(provider=LLMProvider.ANTHROPIC, model_name="claude-3-5-sonnet-20241022")
gemini_llm = LLM.create(provider=LLMProvider.GEMINI, model_name="gemini-1.5-pro")

# First level: OpenAI -> Anthropic
reliable_llm_1 = ReliableLLM(openai_llm, anthropic_llm)

# Second level: (OpenAI/Anthropic) -> Gemini
reliable_llm_2 = ReliableLLM(reliable_llm_1, gemini_llm)

# Will try OpenAI -> Anthropic -> Gemini
response = reliable_llm_2.generate_response(
    prompt="Explain neural networks"
)

With Custom Retry Logic

# Aggressive retry strategy
reliable_llm = ReliableLLM(
    primary_llm,
    secondary_llm,
    max_retries=5,          # More retry attempts
    initial_delay=0.5,      # Shorter initial delay
    exponential_base=1.5    # Slower backoff growth
)

# Conservative retry strategy
reliable_llm = ReliableLLM(
    primary_llm,
    secondary_llm,
    max_retries=2,          # Fewer retries
    initial_delay=2.0,      # Longer initial delay
    exponential_base=3.0    # Faster backoff growth
)

Use Cases

Complete Example: Production Setup

Here's a production-ready example with logging and error handling:

from SimplerLLM.language.llm import LLM, LLMProvider
from SimplerLLM.language.llm.reliable import ReliableLLM
import logging

# Configure logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

def create_reliable_llm():
    """Create a production-ready ReliableLLM instance"""
    try:
        # Primary: OpenAI GPT-4 (high quality)
        primary_llm = LLM.create(
            provider=LLMProvider.OPENAI,
            model_name="gpt-4o",
            temperature=0.7
        )
        logger.info("Primary LLM (OpenAI) initialized")

        # Secondary: Anthropic Claude (reliable backup)
        secondary_llm = LLM.create(
            provider=LLMProvider.ANTHROPIC,
            model_name="claude-3-5-sonnet-20241022",
            temperature=0.7
        )
        logger.info("Secondary LLM (Anthropic) initialized")

        # Create ReliableLLM with validation
        reliable_llm = ReliableLLM(
            primary_llm,
            secondary_llm,
            max_retries=3,
            initial_delay=1.0,
            exponential_base=2.0,
            validate_on_init=True
        )
        logger.info("ReliableLLM initialized successfully")

        return reliable_llm

    except Exception as e:
        logger.error(f"Failed to initialize ReliableLLM: {e}")
        raise

def generate_with_fallback(reliable_llm, prompt):
    """Generate response with automatic failover"""
    try:
        response, provider, model = reliable_llm.generate_response(
            prompt=prompt,
            return_metadata=True
        )

        logger.info(f"Successfully generated response using {provider.name}/{model}")
        return response

    except Exception as e:
        logger.error(f"All providers failed: {e}")
        return None

# Usage
if __name__ == "__main__":
    # Initialize ReliableLLM
    reliable_llm = create_reliable_llm()

    # Generate responses
    prompts = [
        "Explain machine learning",
        "What is cloud computing?",
        "Describe the benefits of microservices"
    ]

    for prompt in prompts:
        response = generate_with_fallback(reliable_llm, prompt)
        if response:
            print(f"\nPrompt: {prompt}")
            print(f"Response: {response[:200]}...")
        else:
            print(f"\nFailed to generate response for: {prompt}")

Error Handling

ReliableLLM handles errors automatically, but you should still implement proper error handling:

from SimplerLLM.language.llm import LLM, LLMProvider
from SimplerLLM.language.llm.reliable import ReliableLLM

try:
    # Create ReliableLLM
    primary = LLM.create(provider=LLMProvider.OPENAI, model_name="gpt-4o")
    secondary = LLM.create(provider=LLMProvider.ANTHROPIC, model_name="claude-3-5-sonnet-20241022")

    reliable_llm = ReliableLLM(primary, secondary)

    # Generate response
    response = reliable_llm.generate_response(
        prompt="Your prompt here"
    )

    print(f"Success: {response}")

except ValueError as e:
    # Configuration errors (invalid models, missing API keys, etc.)
    print(f"Configuration error: {e}")

except Exception as e:
    # Both providers failed
    print(f"All providers failed: {e}")
    # Implement your fallback strategy here
    # - Queue for later processing
    # - Return cached response
    # - Show user-friendly error message

Best Practices

What's Next?