​
HybridRouter Objects

class HybridRouter(BaseRouter)
A hybrid layer that uses both dense and sparse embeddings to classify routes.

​
__init__

def __init__(encoder: DenseEncoder,
             sparse_encoder: Optional[SparseEncoder] = None,
             llm: Optional[BaseLLM] = None,
             routes: Optional[List[Route]] = None,
             index: Optional[HybridLocalIndex] = None,
             top_k: int = 5,
             aggregation: str = "mean",
             auto_sync: Optional[str] = None,
             alpha: float = 0.3,
             init_async_index: bool = False)
Initialize the HybridRouter. Arguments:
  • encoder (DenseEncoder): The dense encoder to use.
  • sparse_encoder (Optional[SparseEncoder]): The sparse encoder to use.

​
add

def add(routes: List[Route] | Route)
Add a route to the local HybridRouter and index. Arguments:
  • route (Route): The route to add.

​
aadd

async def aadd(routes: List[Route] | Route)
Add a route to the local HybridRouter and index asynchronously. Arguments:
  • routes (List[Route] | Route): The route(s) to add.

​
__call__

def __call__(
    text: Optional[str] = None,
    vector: Optional[List[float] | np.ndarray] = None,
    simulate_static: bool = False,
    route_filter: Optional[List[str]] = None,
    limit: int | None = 1,
    sparse_vector: dict[int, float] | SparseEmbedding | None = None
) -> RouteChoice | list[RouteChoice]
Call the HybridRouter. Arguments:
  • text (Optional[str]): The text to encode.
  • vector (Optional[List[float] | np.ndarray]): The vector to encode.
  • simulate_static (bool): Whether to simulate a static route.
  • route_filter (Optional[List[str]]): The route filter to use.
  • limit (int | None): The number of routes to return, defaults to 1. If set to None, no limit is applied and all routes are returned.
  • Optional[str]0 (Optional[str]1): The sparse vector to use.
Returns: Optional[str]2: A RouteChoice or a list of RouteChoices.

​
acall

async def acall(
    text: Optional[str] = None,
    vector: Optional[List[float] | np.ndarray] = None,
    limit: int | None = 1,
    simulate_static: bool = False,
    route_filter: Optional[List[str]] = None,
    sparse_vector: dict[int, float] | SparseEmbedding | None = None
) -> RouteChoice | list[RouteChoice]
Asynchronously call the router to get a route choice. Arguments:
  • text (Optional[str]): The text to route.
  • vector (Optional[List[float] | np.ndarray]): The vector to route.
  • simulate_static (bool): Whether to simulate a static route (ie avoid dynamic route LLM calls during fit or evaluate).
  • route_filter (Optional[List[str]]): The route filter to use.
  • sparse_vector (dict[int, float] | SparseEmbedding | None): The sparse vector to use.
Returns: Optional[str]0: The route choice.

​
fit

def fit(X: List[str],
        y: List[str],
        batch_size: int = 500,
        max_iter: int = 500,
        local_execution: bool = False)
Fit the HybridRouter. Arguments:
  • X (List[str]): The input data.
  • y (List[str]): The output data.
  • batch_size (int): The batch size to use for fitting.
  • max_iter (int): The maximum number of iterations to use for fitting.
  • local_execution (bool): Whether to execute the fitting locally.

​
evaluate

def evaluate(X: List[str], y: List[str], batch_size: int = 500) -> float
Evaluate the accuracy of the route selection. Arguments:
  • X (List[str]): The input data.
  • y (List[str]): The output data.
  • batch_size (int): The batch size to use for evaluation.
Returns: float: The accuracy of the route selection.