Guides¶

Master Claif Knollm with our comprehensive guides covering everything from basic multi-provider strategies to advanced production deployment patterns.

Guide Categories¶

:material-network:{ .lg .middle } Multi-Provider Strategies

Learn to leverage multiple LLM providers for reliability, cost optimization, and performance.

:octicons-arrow-right-24: Multi-Provider Guide
:material-cash:{ .lg .middle } Cost Optimization

Master techniques to minimize LLM expenses while maintaining quality and performance.

:octicons-arrow-right-24: Cost Optimization
:material-chart-line:{ .lg .middle } Monitoring & Analytics

Track performance, costs, and usage patterns to optimize your LLM operations.

:octicons-arrow-right-24: Monitoring Guide
:material-rocket:{ .lg .middle } Best Practices

Production-ready patterns and practices for deploying Knollm in real-world applications.

:octicons-arrow-right-24: Best Practices

By Experience Level¶

BeginnerIntermediateAdvanced

New to LLM integration? Start here:

Installation - Get set up
Quick Start - First application
Multi-Provider Basics - Use multiple providers
Cost Control - Set spending limits

Ready to optimize your setup:

Advanced Routing - Smart provider selection
Cost Optimization - Minimize expenses
Performance Tuning - Speed up requests
Error Handling - Robust applications

Production deployment and scaling:

Production Deployment - Enterprise patterns
Advanced Monitoring - Comprehensive observability
Custom Routing - Build your own logic
Performance at Scale - Handle high volume

By Use Case¶

Development & TestingProduction ApplicationsHigh-Volume ProcessingResearch & Experimentation

Focus: Minimize costs, maximize flexibility

Focus: Reliability, performance, monitoring

Focus: Cost efficiency, speed, scalability

Focus: Model variety, cost control, analysis

Featured Strategies¶

Cost Optimization Quick Wins¶

Immediate ways to reduce your LLM costs:

Use Cost-Optimized Routing

from claif_knollm import KnollmClient, RoutingStrategy

client = KnollmClient(routing_strategy=RoutingStrategy.COST_OPTIMIZED)

Set Budget Limits

client = KnollmClient(
    max_cost_per_request=0.01,
    daily_budget=50.00
)

Choose Budget Providers

client = KnollmClient(
    fallback_providers=["groq", "deepseek", "together"]
)

Reliability Quick Setup¶

Ensure your application stays online:

Multiple Fallback Providers

client = KnollmClient(
    fallback_providers=["openai", "anthropic", "groq", "deepseek"]
)

Health Check Monitoring

health_status = await client.check_provider_health()

Automatic Retry Logic

client = KnollmClient(
    max_retries=3,
    retry_backoff=2.0
)

Common Patterns¶

Pattern: Smart Fallback Chain¶

from claif_knollm import KnollmClient, RoutingStrategy

client = KnollmClient(
    routing_strategy=RoutingStrategy.BALANCED,
    fallback_providers=[
        "openai",      # Primary: High quality
        "anthropic",   # Backup: Also high quality  
        "groq",        # Budget: Fast and cheap
        "deepseek"     # Emergency: Very cheap
    ]
)

Use Case: Production applications that need reliability with cost control.

Pattern: Development vs Production¶

import os
from claif_knollm import KnollmClient, RoutingStrategy

# Different strategies for different environments
if os.getenv("ENVIRONMENT") == "production":
    client = KnollmClient(
        routing_strategy=RoutingStrategy.QUALITY_OPTIMIZED,
        fallback_providers=["openai", "anthropic"]
    )
else:
    client = KnollmClient(
        routing_strategy=RoutingStrategy.COST_OPTIMIZED,
        fallback_providers=["groq", "deepseek"]
    )

Use Case: Optimize costs in development while ensuring quality in production.

Pattern: Task-Specific Routing¶

from claif_knollm import ModelRegistry, ModelCapability

registry = ModelRegistry()

async def route_by_task(task_type: str, messages: list):
    if task_type == "coding":
        # Use specialized code models
        model = registry.find_optimal_model(
            required_capabilities=[ModelCapability.CODE_GENERATION],
            max_cost_per_1k_tokens=0.005
        )
    elif task_type == "analysis":
        # Use high-quality reasoning models  
        model = registry.find_optimal_model(
            required_capabilities=[ModelCapability.REASONING],
            min_quality_score=0.9
        )
    else:
        # Use general-purpose budget models
        model = registry.find_optimal_model(
            max_cost_per_1k_tokens=0.002
        )

    return await client.create_completion(
        messages=messages,
        model=model.id
    )

Use Case: Optimize model selection based on specific task requirements.

Performance Tips¶

Latency Optimization¶

Use Regional Providers - Choose providers with servers near your users
Enable Caching - Cache common responses to avoid repeated requests
Batch Requests - Process multiple requests together when possible
Async Operations - Use async/await for concurrent processing

Cost Optimization¶

Token Management - Monitor and optimize token usage
Model Selection - Use smaller models for simpler tasks
Request Optimization - Craft efficient prompts
Budget Monitoring - Set alerts before limits are reached

Reliability Improvements¶

Multiple Providers - Never depend on a single provider
Health Monitoring - Continuously check provider status
Circuit Breakers - Temporarily disable failing providers
Graceful Degradation - Have fallback behavior for failures

What's Next?¶

Choose your learning path:

For Beginners¶

Start with Multi-Provider Strategies → to understand the fundamentals.

For Cost-Conscious Users¶

Jump to Cost Optimization → to minimize your expenses.

For Production Users¶

Begin with Best Practices → for enterprise deployment.

For Analytics Users¶

Explore Monitoring & Analytics → for comprehensive tracking.

🎯 Quick Start

Not sure where to begin? Start with the Multi-Provider guide - it covers the core concepts that apply to all other areas.