LlamaIndex RouterQueryEngine — selector picks wrong engine or none

from llama_index.core.query_engine import RouterQueryEngine
from llama_index.core.selectors import PydanticSingleSelector, PydanticMultiSelector
from llama_index.core.tools import QueryEngineTool, ToolMetadata
from llama_index.llms.openai import OpenAI

llm = OpenAI(model="gpt-4o-mini")

# Rich tool descriptions with explicit anti-triggers
policy_tool = QueryEngineTool(
    query_engine=policy_index.as_query_engine(similarity_top_k=6),
    metadata=ToolMetadata(
        name="company_policies",
        description=(
            "Company policies including refund policy, return policy, warranty, "
            "shipping terms, and terms of service.\n\n"
            "USE THIS FOR queries about:\n"
            "- Refund windows, return conditions, warranty periods\n"
            "- Shipping options, delivery timelines\n"
            "- Terms of service, privacy policy details\n\n"
            "DO NOT USE FOR:\n"
            "- Product specifications or features\n"
            "- Pricing of specific products\n"
            "- Availability inventory"
        ),
    ),
)

product_tool = QueryEngineTool(
    query_engine=product_index.as_query_engine(similarity_top_k=6),
    metadata=ToolMetadata(
        name="product_catalog",
        description=(
            "Product catalog including features, specifications, pricing, "
            "and inventory status.\n\n"
            "USE THIS FOR queries about:\n"
            "- Specific product features or technical specs\n"
            "- Product prices and availability\n"
            "- Product comparisons or recommendations\n\n"
            "DO NOT USE FOR:\n"
            "- Refund/return policies (use company_policies)\n"
            "- Order status (use orders_api)"
        ),
    ),
)

# --- Router with a single-select LLM selector ---
router_query_engine = RouterQueryEngine(
    selector=PydanticSingleSelector.from_defaults(llm=llm),
    query_engine_tools=[policy_tool, product_tool],
    verbose=True,   # prints selection reasoning
)

# --- Test various query types ---
for query in [
    "What is the refund window?",
    "What are the specs of the ACME-5000?",
    "What is the return window for the ACME-5000 specifically?",  # ambiguous
]:
    response = router_query_engine.query(query)
    print(f"\nQ: {query}")
    print(f"A: {response.response[:200]}")

from llama_index.core.query_engine import RouterQueryEngine
from llama_index.core.selectors import PydanticMultiSelector

router = RouterQueryEngine(
    selector=PydanticMultiSelector.from_defaults(llm=llm, max_outputs=2),
    query_engine_tools=[policy_tool, product_tool, orders_tool],
    verbose=True,
)

# Query that spans multiple engines
response = router.query(
    "What is the return window for the ACME-5000, and is it currently in stock?"
)
print(response)

# --- Router with LLM selector for models that do not do function calling ---
from llama_index.core.selectors import LLMSingleSelector, LLMMultiSelector

# LLMSingleSelector: outputs "the answer is: X" free-text; parser extracts the choice
# Use when your LLM does NOT support structured output well
router_llm = RouterQueryEngine(
    selector=LLMSingleSelector.from_defaults(llm=llm),
    query_engine_tools=[policy_tool, product_tool],
)

# --- Fallback strategy ---
# When all tools score low, fall back to a "generic" engine
generic_engine = general_index.as_query_engine()
generic_tool = QueryEngineTool(
    query_engine=generic_engine,
    metadata=ToolMetadata(
        name="general_knowledge",
        description="General knowledge fallback for queries that do not fit other tools.",
    ),
)

router_with_fallback = RouterQueryEngine(
    selector=PydanticSingleSelector.from_defaults(llm=llm),
    query_engine_tools=[policy_tool, product_tool, generic_tool],
    verbose=True,
)

from llama_index.core.query_engine import RouterQueryEngine
from llama_index.core.selectors import (
    PydanticSingleSelector,
    LLMSingleSelector,
    EmbeddingSingleSelector,
)
from llama_index.embeddings.openai import OpenAIEmbedding

# --- Build multiple routers with different selectors ---
tools = [policy_tool, product_tool, orders_tool]

routers = {
    "pydantic": RouterQueryEngine(
        selector=PydanticSingleSelector.from_defaults(llm=llm),
        query_engine_tools=tools,
    ),
    "llm": RouterQueryEngine(
        selector=LLMSingleSelector.from_defaults(llm=llm),
        query_engine_tools=tools,
    ),
    "embedding": RouterQueryEngine(
        selector=EmbeddingSingleSelector.from_defaults(
            embed_model=OpenAIEmbedding(model="text-embedding-3-small"),
        ),
        query_engine_tools=tools,
    ),
}

# --- Test set with expected routing ---
test_set = [
    ("What is the refund window?", "company_policies"),
    ("Show me the ACME-5000 features", "product_catalog"),
    ("Where is my order?", "orders_api"),
    # ...
]

for name, router in routers.items():
    correct = 0
    for query, expected_tool in test_set:
        response = router.query(query)
        # metadata.selector_result shows which was selected
        selected = getattr(response, "metadata", {}).get("selector_result", {}).get("selection", "?")
        # (the exact attribute name may vary; verify in your version)
        if selected == expected_tool:
            correct += 1
    print(f"{name} selector: {correct}/{len(test_set)} correct")

# Also log embedding selector cost: it does not call the LLM per query,
# which makes it cheaper — worth it if quality matches