Ignis Router

Intelligent LLM Routing Library for Python

Automatically selects the best language model for every query using ML routers, rule-based intent detection, weighted scoring, and provider fallback.

What is Ignis Router?

Ignis Router is a production-ready Python package that sits between your application and LLM providers. It uses machine learning to predict the optimal model for each query, rule-based intent detection as an intelligent fallback, and automatic provider switching when API keys are unavailable.

Your App → Ignis Router → Best LLM (OpenAI / Anthropic / Gemini) → Response

Why use it?

• Cost savings — Routes simple queries to cheaper models, complex ones to premium models
• Quality optimization — ML routers trained on 50k+ examples learn which model performs best for which query type
• Zero downtime — Automatic fallback when a provider is unavailable
• Full observability — Every routing decision is logged with correlation IDs

Key Features

Installation

pip install git+https://github.com/Infogain-GenAI/ignis_router.git@main

pip install "ignis_router[all]"         # All LLM providers
pip install "ignis_router[dashboard]"   # Streamlit dashboard
pip install "ignis_router[dev]"         # Development tools

Quick Start

1. Create .env

OPENAI_API_KEY=sk-your-key-here
ML_ROUTER_TYPE=svm
ENABLE_ML_MODEL_HINT_ROUTING=true

2. Route + Call LLM

from ignis_router import chat

@chat(system_prompt="You are a helpful assistant")
def ask(query, response):
    rd = response["routing_decision"]
    print(f"ML Predicted:  {rd['ml_router_predicted']}")
    print(f"Final Model:   {rd['final_model']}")
    print(f"Intent:        {rd['intent']}")
    print(f"Response:      {response['content'][:100]}")
    return response

ask("Write a Python function to sort a list")

3. Output

ML Predicted:  qwen2.5-7b-instruct
Final Model:   gpt-4.1-2025-04-14 (openai)
Intent:        code_generation
Response:      Here's a Python sorting function...

Usage Options

Decorators (simplest)

from ignis_router import route, chat

@route()
def handle(query, routing_result, routing_decision):
    return routing_decision["final_model"]

@chat()
def ask(query, response):
    return response["content"]

Direct Python API

from ignis_router import Router

router = Router()
router.register_supported_models()
router.register_default_intent_rules()
router.enable_llm_clients()

response = router.chat("Explain quantum computing")
print(response["content"])

REST API

python -m ignis_router.api.run_api
# Server: http://127.0.0.1:8080
# Swagger: http://127.0.0.1:8080/docs

curl -X POST http://localhost:8080/chat \
  -H "Content-Type: application/json" \
  -d '{"query": "Write Python code for sorting"}'

SDK Client

from ignis_router import IgnisClient

with IgnisClient("http://127.0.0.1:8080") as client:
    result = client.chat("Write Python code")
    print(result.content)

How It Works

User Query: "Write a Python API with authentication"
     │
     ▼
┌─ Intent Detection ────────────────────────────┐
│  Semantic ML → confidence 0.92 → code_gen     │
└───────────────────────────────────────────────┘
     │
     ▼
┌─ ML Router (SVM) ────────────────────────────┐
│  Predicts: qwen2.5-7b-instruct               │
└───────────────────────────────────────────────┘
     │
     ▼
┌─ Provider Check ─────────────────────────────┐
│  qwen2.5 → No API key → Fallback to OpenAI  │
└───────────────────────────────────────────────┘
     │
     ▼
┌─ LLM Call ───────────────────────────────────┐
│  gpt-4.1 (OpenAI) → AI Response             │
└───────────────────────────────────────────────┘
     │
     ▼
┌─ Persistence ────────────────────────────────┐
│  PostgreSQL + JSON Logs + Correlation IDs     │
└───────────────────────────────────────────────┘

ML Routers

Four pre-trained routers from LLMRouter (open-source, UIUC):

ML_ROUTER_TYPE=svm  # or knn, graph, mf

API Endpoints

Dashboard

pip install "ignis_router[dashboard]"
python -m streamlit run examples/streamlit_dashboard.py

Visual analytics: KPIs, model distribution, confidence histograms, per-model performance, routing log.

Configuration

See user_guide.md for the full environment variable reference.

Documentation

Project Structure

src/ignis_router/
├── api/           # FastAPI REST service + SDK client
├── configs/       # Routing strategy YAMLs + ML router configs
├── core/          # Router, routing engine, model selector
├── data/          # Intent training data
├── db/            # PostgreSQL persistence
├── detection/     # Intent detection (semantic + rule-based)
├── evaluation/    # Metrics, dashboard, reports
├── llm/           # LLM provider clients (OpenAI, Anthropic, Gemini)
├── ml/            # LLMRouter integration + ML inference
├── models/        # Pre-trained ML router models (.pkl, .pt)
└── scripts/       # Training scripts

Development

git clone https://github.com/Infogain-GenAI/ignis_router.git
cd ignis_router
pip install -e ".[dev,all,dashboard]"
python -m pytest tests/ -v

License

This project is licensed under the MIT License — see LICENSE for details.

Built by Infogain GenAI