Zum Hauptinhalt springen

Router - Lastenausgleich

LiteLLM verwaltet

  • Lastverteilung über mehrere Deployments (z. B. Azure/OpenAI)
  • Priorisierung wichtiger Anfragen, um sicherzustellen, dass sie nicht fehlschlagen (d. h. Warteschlangenbildung)
  • Grundlegende Zuverlässigkeitslogik - Cooldowns, Fallbacks, Timeouts und Wiederholungsversuche (fest + exponentielle Rückfallverzögerung) über mehrere Deployments/Anbieter.

In der Produktion unterstützt litellm die Verwendung von Redis zur Nachverfolgung von Cooldown-Servern und zur Nutzung (Verwaltung von TPM/RPM-Limits).

Info

Wenn Sie einen Server zur Lastverteilung über verschiedene LLM-APIs wünschen, verwenden Sie unseren LiteLLM Proxy Server

Lastverteilung​

(s/o @paulpierre und Sweep Proxy für ihre Beiträge zu dieser Implementierung) Code anzeigen

Schnellstart​

Lastverteilung über mehrere Azure/Bedrock/Anbieter-Deployments. LiteLLM kümmert sich um Wiederholungsversuche in verschiedenen Regionen, falls ein Aufruf fehlschlägt.

from litellm import Router

model_list = [{ # list of model deployments 
    "model_name": "gpt-3.5-turbo", # model alias -> loadbalance between models with same `model_name`
    "litellm_params": { # params for litellm completion/embedding call 
        "model": "azure/chatgpt-v-2", # actual model name
        "api_key": os.getenv("AZURE_API_KEY"),
        "api_version": os.getenv("AZURE_API_VERSION"),
        "api_base": os.getenv("AZURE_API_BASE")
    }
}, {
    "model_name": "gpt-3.5-turbo", 
    "litellm_params": { # params for litellm completion/embedding call 
        "model": "azure/chatgpt-functioncalling", 
        "api_key": os.getenv("AZURE_API_KEY"),
        "api_version": os.getenv("AZURE_API_VERSION"),
        "api_base": os.getenv("AZURE_API_BASE")
    }
}, {
    "model_name": "gpt-3.5-turbo", 
    "litellm_params": { # params for litellm completion/embedding call 
        "model": "gpt-3.5-turbo", 
        "api_key": os.getenv("OPENAI_API_KEY"),
    }
}, {
    "model_name": "gpt-4", 
    "litellm_params": { # params for litellm completion/embedding call 
        "model": "azure/gpt-4", 
        "api_key": os.getenv("AZURE_API_KEY"),
        "api_base": os.getenv("AZURE_API_BASE"),
        "api_version": os.getenv("AZURE_API_VERSION"),
    }
}, {
    "model_name": "gpt-4", 
    "litellm_params": { # params for litellm completion/embedding call 
        "model": "gpt-4", 
        "api_key": os.getenv("OPENAI_API_KEY"),
    }
},

]

router = Router(model_list=model_list)

# openai.ChatCompletion.create replacement
# requests with model="gpt-3.5-turbo" will pick a deployment where model_name="gpt-3.5-turbo"
response = await router.acompletion(model="gpt-3.5-turbo", 
                messages=[{"role": "user", "content": "Hey, how's it going?"}])

print(response)

# openai.ChatCompletion.create replacement
# requests with model="gpt-4" will pick a deployment where model_name="gpt-4"
response = await router.acompletion(model="gpt-4", 
                messages=[{"role": "user", "content": "Hey, how's it going?"}])

print(response)

Verfügbare Endpunkte​

  • router.completion() - Chat-Completion-Endpunkt für über 100 LLMs
  • router.acompletion() - asynchrone Chat-Completion-Aufrufe
  • router.embedding() - Embedding-Endpunkt für Azure, OpenAI, Huggingface-Endpunkte
  • router.aembedding() - asynchrone Embedding-Aufrufe
  • router.text_completion() - Completion-Aufrufe im alten OpenAI /v1/completions-Endpunktformat
  • router.atext_completion() - asynchrone Text-Completion-Aufrufe
  • router.image_generation() - Completion-Aufrufe im OpenAI /v1/images/generations-Endpunktformat
  • router.aimage_generation() - asynchrone Bildgenerierungsaufrufe

Erweitert - Routing-Strategien ⭐️​

Routing-Strategien - Gewichtet, Ratenbegrenzung bewusst, am wenigsten beschäftigt, Latenz-basiert, Kosten-basiert​

Der Router bietet 4 Strategien zum Routen Ihrer Aufrufe über mehrere Deployments.

🎉 NEU Dies ist eine asynchrone Implementierung von nutzungsbasierter Routenplanung.

Filtert Deployment heraus, wenn TPM/RPM-Limit überschritten wird - Wenn Sie die TPM/RPM-Limits des Deployments angeben.

Routet zum **Deployment mit der geringsten TPM-Auslastung** für diese Minute.

In der Produktion verwenden wir Redis, um die Auslastung (TPM/RPM) über mehrere Deployments hinweg zu verfolgen. Diese Implementierung verwendet **asynchrone Redis-Aufrufe** (redis.incr und redis.mget).

Für Azure erhalten Sie 6 RPM pro 1000 TPM

from litellm import Router 


model_list = [{ # list of model deployments 
    "model_name": "gpt-3.5-turbo", # model alias 
    "litellm_params": { # params for litellm completion/embedding call 
        "model": "azure/chatgpt-v-2", # actual model name
        "api_key": os.getenv("AZURE_API_KEY"),
        "api_version": os.getenv("AZURE_API_VERSION"),
        "api_base": os.getenv("AZURE_API_BASE")
        "tpm": 100000,
        "rpm": 10000,
    }, 
}, {
    "model_name": "gpt-3.5-turbo", 
    "litellm_params": { # params for litellm completion/embedding call 
        "model": "azure/chatgpt-functioncalling", 
        "api_key": os.getenv("AZURE_API_KEY"),
        "api_version": os.getenv("AZURE_API_VERSION"),
        "api_base": os.getenv("AZURE_API_BASE")
        "tpm": 100000,
        "rpm": 1000,
    },
}, {
    "model_name": "gpt-3.5-turbo", 
    "litellm_params": { # params for litellm completion/embedding call 
        "model": "gpt-3.5-turbo", 
        "api_key": os.getenv("OPENAI_API_KEY"),
        "tpm": 100000,
        "rpm": 1000,
    },
}]
router = Router(model_list=model_list, 
                redis_host=os.environ["REDIS_HOST"], 
                redis_password=os.environ["REDIS_PASSWORD"], 
                redis_port=os.environ["REDIS_PORT"], 
                routing_strategy="usage-based-routing-v2" # 👈 KEY CHANGE
                enable_pre_call_checks=True, # enables router rate limits for concurrent calls
                )

response = await router.acompletion(model="gpt-3.5-turbo", 
                messages=[{"role": "user", "content": "Hey, how's it going?"}]

print(response)

Grundlegende Zuverlässigkeit​

Gewichtete Deployments​

Setzen Sie weight für ein Deployment, um ein Deployment häufiger als andere auszuwählen.

Dies funktioniert über die Routing-Strategie **simple-shuffle** (dies ist die Standardeinstellung, wenn keine Routing-Strategie ausgewählt ist).

from litellm import Router 

model_list = [
    {
        "model_name": "o1",
        "litellm_params": {
            "model": "o1-preview", 
            "api_key": os.getenv("OPENAI_API_KEY"), 
            "weight": 1
        },
    },
    {
        "model_name": "o1",
        "litellm_params": {
            "model": "o1-preview", 
            "api_key": os.getenv("OPENAI_API_KEY"), 
            "weight": 2 # 👈 PICK THIS DEPLOYMENT 2x MORE OFTEN THAN o1-preview
        },
    },
]

router = Router(model_list=model_list, routing_strategy="cost-based-routing")

response = await router.acompletion(
    model="gpt-3.5-turbo", 
    messages=[{"role": "user", "content": "Hey, how's it going?"}]
)
print(response)

Maximale parallele Anfragen (ASYNC)​

Wird in Semaphore für asynchrone Anfragen an den Router verwendet. Begrenzt die maximalen gleichzeitigen Aufrufe an ein Deployment. Nützlich in Szenarien mit hohem Datenverkehr.

Wenn tpm/rpm gesetzt ist und keine maximale parallele Anfragebegrenzung angegeben ist, verwenden wir RPM oder berechnete RPM (tpm/1000/6) als maximale parallele Anfragebegrenzung.

from litellm import Router 

model_list = [{
    "model_name": "gpt-4",
    "litellm_params": {
        "model": "azure/gpt-4",
        ...
        "max_parallel_requests": 10 # 👈 SET PER DEPLOYMENT
    }
}]

### OR ### 

router = Router(model_list=model_list, default_max_parallel_requests=20) # 👈 SET DEFAULT MAX PARALLEL REQUESTS 


# deployment max parallel requests > default max parallel requests

Code anzeigen

Cooldowns​

Legen Sie das Limit fest, wie viele Aufrufe ein Modell pro Minute fehlschlagen darf, bevor es für eine Minute heruntergefahren wird.

from litellm import Router

model_list = [{...}]

router = Router(model_list=model_list, 
                allowed_fails=1,      # cooldown model if it fails > 1 call in a minute. 
                cooldown_time=100    # cooldown the deployment for 100 seconds if it num_fails > allowed_fails
        )

user_message = "Hello, whats the weather in San Francisco??"
messages = [{"content": user_message, "role": "user"}]

# normal call 
response = router.completion(model="gpt-3.5-turbo", messages=messages)

print(f"response: {response}")

Erwartete Antwort

No deployments available for selected model, Try again in 60 seconds. Passed model=claude-3-5-sonnet. pre-call-checks=False, allowed_model_region=n/a.

Cooldowns deaktivieren​

from litellm import Router 


router = Router(..., disable_cooldowns=True)

Wiederholungsversuche​

Sowohl für asynchrone als auch für synchrone Funktionen unterstützen wir das Wiederholen fehlgeschlagener Anfragen.

Für RateLimitError implementieren wir exponentielle Rückfallverzögerungen.

Für generische Fehler wiederholen wir sofort.

Hier ein kurzer Überblick, wie wir num_retries = 3 einstellen können.

from litellm import Router

model_list = [{...}]

router = Router(model_list=model_list,  
                num_retries=3)

user_message = "Hello, whats the weather in San Francisco??"
messages = [{"content": user_message, "role": "user"}]

# normal call 
response = router.completion(model="gpt-3.5-turbo", messages=messages)

print(f"response: {response}")

Wir unterstützen auch die Festlegung der minimalen Wartezeit, bevor ein fehlgeschlagener Versuch wiederholt wird. Dies geschieht über den Parameter retry_after.

from litellm import Router

model_list = [{...}]

router = Router(model_list=model_list,  
                num_retries=3, retry_after=5) # waits min 5s before retrying request

user_message = "Hello, whats the weather in San Francisco??"
messages = [{"content": user_message, "role": "user"}]

# normal call 
response = router.completion(model="gpt-3.5-turbo", messages=messages)

print(f"response: {response}")

[Erweitert]: Benutzerdefinierte Wiederholungsversuche, Cooldowns basierend auf Fehlertyp​

  • Verwenden Sie RetryPolicy, wenn Sie num_retries basierend auf der erhaltenen Ausnahme festlegen möchten.
  • Verwenden Sie AllowedFailsPolicy, um eine benutzerdefinierte Anzahl von allowed_fails pro Minute festzulegen, bevor ein Deployment heruntergefahren wird.

Alle Ausnahmetypen anzeigen

Beispiel

retry_policy = RetryPolicy(
    ContentPolicyViolationErrorRetries=3,         # run 3 retries for ContentPolicyViolationErrors
    AuthenticationErrorRetries=0,                 # run 0 retries for AuthenticationErrorRetries
)

allowed_fails_policy = AllowedFailsPolicy(
    ContentPolicyViolationErrorAllowedFails=1000, # Allow 1000 ContentPolicyViolationError before cooling down a deployment
    RateLimitErrorAllowedFails=100,               # Allow 100 RateLimitErrors before cooling down a deployment
)

Beispielverwendung

from litellm.router import RetryPolicy, AllowedFailsPolicy

retry_policy = RetryPolicy(
    ContentPolicyViolationErrorRetries=3,         # run 3 retries for ContentPolicyViolationErrors
    AuthenticationErrorRetries=0,                 # run 0 retries for AuthenticationErrorRetries
    BadRequestErrorRetries=1,
    TimeoutErrorRetries=2,
    RateLimitErrorRetries=3,
)

allowed_fails_policy = AllowedFailsPolicy(
    ContentPolicyViolationErrorAllowedFails=1000, # Allow 1000 ContentPolicyViolationError before cooling down a deployment
    RateLimitErrorAllowedFails=100,               # Allow 100 RateLimitErrors before cooling down a deployment
)

router = litellm.Router(
    model_list=[
        {
            "model_name": "gpt-3.5-turbo",  # openai model name
            "litellm_params": {  # params for litellm completion/embedding call
                "model": "azure/chatgpt-v-2",
                "api_key": os.getenv("AZURE_API_KEY"),
                "api_version": os.getenv("AZURE_API_VERSION"),
                "api_base": os.getenv("AZURE_API_BASE"),
            },
        },
        {
            "model_name": "bad-model",  # openai model name
            "litellm_params": {  # params for litellm completion/embedding call
                "model": "azure/chatgpt-v-2",
                "api_key": "bad-key",
                "api_version": os.getenv("AZURE_API_VERSION"),
                "api_base": os.getenv("AZURE_API_BASE"),
            },
        },
    ],
    retry_policy=retry_policy,
    allowed_fails_policy=allowed_fails_policy,
)

response = await router.acompletion(
    model=model,
    messages=messages,
)

Caching​

In der Produktion empfehlen wir die Verwendung eines Redis-Caches. Für schnelles lokales Testen unterstützen wir auch einfaches In-Memory-Caching.

In-Memory-Cache

router = Router(model_list=model_list, 
                cache_responses=True)

print(response)

Redis-Cache

router = Router(model_list=model_list, 
                redis_host=os.getenv("REDIS_HOST"), 
                redis_password=os.getenv("REDIS_PASSWORD"), 
                redis_port=os.getenv("REDIS_PORT"),
                cache_responses=True)

print(response)

Übergeben Sie die Redis-URL, zusätzliche kwargs 

router = Router(model_list: Optional[list] = None,
                 ## CACHING ## 
                 redis_url=os.getenv("REDIS_URL")",
                 cache_kwargs= {}, # additional kwargs to pass to RedisCache (see caching.py)
                 cache_responses=True)

Vorab-Aufrufprüfungen (Kontextfenster, EU-Regionen)​

Aktivieren Sie Vorab-Aufrufprüfungen, um herauszufiltern

  1. Deployments mit einem Kontextfensterlimit kleiner als die Nachrichten für einen Aufruf.
  2. Deployments außerhalb der EU-Region

1. Vorab-Aufrufprüfungen aktivieren

from litellm import Router 
# ...
router = Router(model_list=model_list, enable_pre_call_checks=True) # 👈 Set to True

2. Modellliste einrichten

Für Kontextfensterprüfungen bei Azure-Deployments legen Sie das Basismodell fest. Wählen Sie das Basismodell aus dieser Liste, alle Azure-Modelle beginnen mit azure/.

Für die Filterung nach 'EU-Region' legen Sie den 'region_name' des Deployments fest.

Hinweis: Wir leiten den region_name für Vertex AI, Bedrock und IBM WatsonxAI automatisch basierend auf Ihren LiteLLM-Parametern ab. Für Azure setzen Sie litellm.enable_preview = True.

Code anzeigen

model_list = [
            {
                "model_name": "gpt-3.5-turbo", # model group name
                "litellm_params": {  # params for litellm completion/embedding call
                    "model": "azure/chatgpt-v-2",
                    "api_key": os.getenv("AZURE_API_KEY"),
                    "api_version": os.getenv("AZURE_API_VERSION"),
                    "api_base": os.getenv("AZURE_API_BASE"),
                    "region_name": "eu" # 👈 SET 'EU' REGION NAME
                    "base_model": "azure/gpt-35-turbo", # 👈 (Azure-only) SET BASE MODEL
                },
            },
            {
                "model_name": "gpt-3.5-turbo", # model group name
                "litellm_params": {  # params for litellm completion/embedding call
                    "model": "gpt-3.5-turbo-1106",
                    "api_key": os.getenv("OPENAI_API_KEY"),
                },
            },
            {
                "model_name": "gemini-pro",
                "litellm_params: {
                    "model": "vertex_ai/gemini-pro-1.5", 
                    "vertex_project": "adroit-crow-1234",
                    "vertex_location": "us-east1" # 👈 AUTOMATICALLY INFERS 'region_name'
                }
            }
        ]

router = Router(model_list=model_list, enable_pre_call_checks=True)

3. Testen!

"""
- Give a gpt-3.5-turbo model group with different context windows (4k vs. 16k)
- Send a 5k prompt
- Assert it works
"""
from litellm import Router
import os

model_list = [
    {
        "model_name": "gpt-3.5-turbo",  # model group name
        "litellm_params": {  # params for litellm completion/embedding call
            "model": "azure/chatgpt-v-2",
            "api_key": os.getenv("AZURE_API_KEY"),
            "api_version": os.getenv("AZURE_API_VERSION"),
            "api_base": os.getenv("AZURE_API_BASE"),
            "base_model": "azure/gpt-35-turbo",
        },
        "model_info": {
            "base_model": "azure/gpt-35-turbo", 
        }
    },
    {
        "model_name": "gpt-3.5-turbo",  # model group name
        "litellm_params": {  # params for litellm completion/embedding call
            "model": "gpt-3.5-turbo-1106",
            "api_key": os.getenv("OPENAI_API_KEY"),
        },
    },
]

router = Router(model_list=model_list, enable_pre_call_checks=True) 

text = "What is the meaning of 42?" * 5000

response = router.completion(
    model="gpt-3.5-turbo",
    messages=[
        {"role": "system", "content": text},
        {"role": "user", "content": "Who was Alexander?"},
    ],
)

print(f"response: {response}")

Caching über Modellgruppen hinweg​

Wenn Sie über 2 verschiedene Modellgruppen cachen möchten (z. B. Azure-Deployments und OpenAI), verwenden Sie Caching-Gruppen.

import litellm, asyncio, time
from litellm import Router 

# set os env
os.environ["OPENAI_API_KEY"] = ""
os.environ["AZURE_API_KEY"] = ""
os.environ["AZURE_API_BASE"] = ""
os.environ["AZURE_API_VERSION"] = ""

async def test_acompletion_caching_on_router_caching_groups(): 
    # tests acompletion + caching on router 
    try:
        litellm.set_verbose = True
        model_list = [
            {
                "model_name": "openai-gpt-3.5-turbo",
                "litellm_params": {
                    "model": "gpt-3.5-turbo-0613",
                    "api_key": os.getenv("OPENAI_API_KEY"),
                },
            },
            {
                "model_name": "azure-gpt-3.5-turbo",
                "litellm_params": {
                    "model": "azure/chatgpt-v-2",
                    "api_key": os.getenv("AZURE_API_KEY"),
                    "api_base": os.getenv("AZURE_API_BASE"),
                    "api_version": os.getenv("AZURE_API_VERSION")
                },
            }
        ]

        messages = [
            {"role": "user", "content": f"write a one sentence poem {time.time()}?"}
        ]
        start_time = time.time()
        router = Router(model_list=model_list, 
                cache_responses=True, 
                caching_groups=[("openai-gpt-3.5-turbo", "azure-gpt-3.5-turbo")])
        response1 = await router.acompletion(model="openai-gpt-3.5-turbo", messages=messages, temperature=1)
        print(f"response1: {response1}")
        await asyncio.sleep(1) # add cache is async, async sleep for cache to get set
        response2 = await router.acompletion(model="azure-gpt-3.5-turbo", messages=messages, temperature=1)
        assert response1.id == response2.id
        assert len(response1.choices[0].message.content) > 0
        assert response1.choices[0].message.content == response2.choices[0].message.content
    except Exception as e:
        traceback.print_exc()

asyncio.run(test_acompletion_caching_on_router_caching_groups())

Alarmierung 🚨​

Senden Sie Alarme an Slack / Ihre Webhook-URL für die folgenden Ereignisse

  • LLM API-Ausnahmen
  • Langsame LLM-Antworten

Holen Sie sich eine Slack-Webhook-URL von https://api.slack.com/messaging/webhooks

Verwendung​

Initialisieren Sie ein AlertingConfig und übergeben Sie es an litellm.Router. Der folgende Code löst einen Alarm aus, da api_key=bad-key ungültig ist.

from litellm.router import AlertingConfig
import litellm
import os

router = litellm.Router(
    model_list=[
        {
            "model_name": "gpt-3.5-turbo",
            "litellm_params": {
                "model": "gpt-3.5-turbo",
                "api_key": "bad_key",
            },
        }
    ],
    alerting_config= AlertingConfig(
        alerting_threshold=10,                        # threshold for slow / hanging llm responses (in seconds). Defaults to 300 seconds
        webhook_url= os.getenv("SLACK_WEBHOOK_URL")   # webhook you want to send alerts to
    ),
)
try:
    await router.acompletion(
        model="gpt-3.5-turbo",
        messages=[{"role": "user", "content": "Hey, how's it going?"}],
    )
except:
    pass

Kosten für Azure-Deployments verfolgen​

Problem: Azure gibt gpt-4 in der Antwort zurück, wenn azure/gpt-4-1106-preview verwendet wird. Dies führt zu ungenauen Kostenverfolgung.

Lösung ✅ : Setzen Sie model_info["base_model"] bei Ihrer Router-Initialisierung, damit litellm das richtige Modell für die Berechnung der Azure-Kosten verwendet.

Schritt 1. Router-Einrichtung

from litellm import Router

model_list = [
    { # list of model deployments 
        "model_name": "gpt-4-preview", # model alias 
        "litellm_params": { # params for litellm completion/embedding call 
            "model": "azure/chatgpt-v-2", # actual model name
            "api_key": os.getenv("AZURE_API_KEY"),
            "api_version": os.getenv("AZURE_API_VERSION"),
            "api_base": os.getenv("AZURE_API_BASE")
        },
        "model_info": {
            "base_model": "azure/gpt-4-1106-preview" # azure/gpt-4-1106-preview will be used for cost tracking, ensure this exists in litellm model_prices_and_context_window.json
        }
    }, 
    {
        "model_name": "gpt-4-32k", 
        "litellm_params": { # params for litellm completion/embedding call 
            "model": "azure/chatgpt-functioncalling", 
            "api_key": os.getenv("AZURE_API_KEY"),
            "api_version": os.getenv("AZURE_API_VERSION"),
            "api_base": os.getenv("AZURE_API_BASE")
        },
        "model_info": {
            "base_model": "azure/gpt-4-32k" # azure/gpt-4-32k will be used for cost tracking, ensure this exists in litellm model_prices_and_context_window.json
        }
    }
]

router = Router(model_list=model_list)

Schritt 2. Greifen Sie auf response_cost im benutzerdefinierten Callback zu. **LiteLLM berechnet die Antwortkosten für Sie**.

import litellm
from litellm.integrations.custom_logger import CustomLogger

class MyCustomHandler(CustomLogger):        
    def log_success_event(self, kwargs, response_obj, start_time, end_time): 
        print(f"On Success")
        response_cost = kwargs.get("response_cost")
        print("response_cost=", response_cost)

customHandler = MyCustomHandler()
litellm.callbacks = [customHandler]

# router completion call
response = router.completion(
    model="gpt-4-32k", 
    messages=[{ "role": "user", "content": "Hi who are you"}]
)

Standardmäßige LiteLLM.completion/embedding-Parameter​

Sie können auch Standardparameter für LiteLLM-Completion/Embedding-Aufrufe festlegen. Hier erfahren Sie, wie das geht.

from litellm import Router

fallback_dict = {"gpt-3.5-turbo": "gpt-3.5-turbo-16k"}

router = Router(model_list=model_list, 
                default_litellm_params={"context_window_fallback_dict": fallback_dict})

user_message = "Hello, whats the weather in San Francisco??"
messages = [{"content": user_message, "role": "user"}]

# normal call 
response = router.completion(model="gpt-3.5-turbo", messages=messages)

print(f"response: {response}")

Benutzerdefinierte Callbacks - API-Schlüssel, API-Endpunkt, verwendetes Modell verfolgen​

Wenn Sie den api_key, den api_endpoint, das verwendete Modell und den custom_llm_provider für jeden Completion-Aufruf nachverfolgen müssen, können Sie einen benutzerdefinierten Callback einrichten.

Verwendung​

import litellm
from litellm.integrations.custom_logger import CustomLogger

class MyCustomHandler(CustomLogger):        
    def log_success_event(self, kwargs, response_obj, start_time, end_time): 
        print(f"On Success")
        print("kwargs=", kwargs)
        litellm_params= kwargs.get("litellm_params")
        api_key = litellm_params.get("api_key")
        api_base = litellm_params.get("api_base")
        custom_llm_provider= litellm_params.get("custom_llm_provider")
        response_cost = kwargs.get("response_cost")

        # print the values
        print("api_key=", api_key)
        print("api_base=", api_base)
        print("custom_llm_provider=", custom_llm_provider)
        print("response_cost=", response_cost)

    def log_failure_event(self, kwargs, response_obj, start_time, end_time): 
        print(f"On Failure")
        print("kwargs=")

customHandler = MyCustomHandler()

litellm.callbacks = [customHandler]

# Init Router
router = Router(model_list=model_list, routing_strategy="simple-shuffle")

# router completion call
response = router.completion(
    model="gpt-3.5-turbo", 
    messages=[{ "role": "user", "content": "Hi who are you"}]
)

Router bereitstellen​

Wenn Sie einen Server zur Lastverteilung über verschiedene LLM-APIs wünschen, verwenden Sie unseren LiteLLM Proxy Server

Router debuggen​

Grundlegendes Debugging​

Setzen Sie Router(set_verbose=True)

from litellm import Router

router = Router(
    model_list=model_list,
    set_verbose=True
)

Detailliertes Debugging​

Setzen Sie Router(set_verbose=True,debug_level="DEBUG")

from litellm import Router

router = Router(
    model_list=model_list,
    set_verbose=True,
    debug_level="DEBUG"  # defaults to INFO
)

Sehr detailliertes Debugging​

Setzen Sie litellm.set_verbose=True und Router(set_verbose=True,debug_level="DEBUG")

from litellm import Router
import litellm

litellm.set_verbose = True

router = Router(
    model_list=model_list,
    set_verbose=True,
    debug_level="DEBUG"  # defaults to INFO
)

Router Allgemeine Einstellungen​

Verwendung​

router = Router(model_list=..., router_general_settings=RouterGeneralSettings(async_only_mode=True))

Spezifikation​

class RouterGeneralSettings(BaseModel):
    async_only_mode: bool = Field(
        default=False
    )  # this will only initialize async clients. Good for memory utils
    pass_through_all_models: bool = Field(
        default=False
    )  # if passed a model not llm_router model list, pass through the request to litellm.acompletion/embedding