# Tiny Dancer Routing Integration Plan
## Overview
Integrate AI agent routing capabilities from `ruvector-tiny-dancer` into PostgreSQL, enabling intelligent request routing, model selection, and cost optimization directly in SQL.
## Architecture
```
┌─────────────────────────────────────────────────────────────────┐
│ PostgreSQL Extension │
├─────────────────────────────────────────────────────────────────┤
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ Tiny Dancer Router │ │
│ │ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │ │
│ │ │ FastGRNN │ │ Route │ │ Cost │ │ │
│ │ │ Inference │ │ Classifier │ │ Optimizer │ │ │
│ │ └──────┬───────┘ └──────┬───────┘ └──────┬───────┘ │ │
│ └─────────┼─────────────────┼─────────────────┼───────────┘ │
│ └─────────────────┴─────────────────┘ │
│ ▼ │
│ ┌───────────────────────────┐ │
│ │ Agent Registry & Pool │ │
│ │ (LLMs, Tools, APIs) │ │
│ └───────────────────────────┘ │
└─────────────────────────────────────────────────────────────────┘
```
## Module Structure
```
src/
├── routing/
│ ├── mod.rs # Module exports
│ ├── fastgrnn.rs # FastGRNN neural inference
│ ├── router.rs # Main routing engine
│ ├── classifier.rs # Route classification
│ ├── cost_optimizer.rs # Cost/latency optimization
│ ├── agents/
│ │ ├── registry.rs # Agent registration
│ │ ├── pool.rs # Agent pool management
│ │ └── capabilities.rs # Capability matching
│ ├── policies/
│ │ ├── cost.rs # Cost-based routing
│ │ ├── latency.rs # Latency-based routing
│ │ ├── quality.rs # Quality-based routing
│ │ └── hybrid.rs # Multi-objective routing
│ └── operators.rs # SQL operators
```
## SQL Interface
### Agent Registration
```sql
-- Register AI agents/models
SELECT ruvector_register_agent(
name := 'gpt-4',
agent_type := 'llm',
capabilities := ARRAY['reasoning', 'code', 'analysis', 'creative'],
cost_per_1k_tokens := 0.03,
avg_latency_ms := 2500,
quality_score := 0.95,
metadata := '{"provider": "openai", "context_window": 128000}'
);
SELECT ruvector_register_agent(
name := 'claude-3-haiku',
agent_type := 'llm',
capabilities := ARRAY['fast-response', 'simple-tasks', 'classification'],
cost_per_1k_tokens := 0.00025,
avg_latency_ms := 400,
quality_score := 0.80,
metadata := '{"provider": "anthropic", "context_window": 200000}'
);
SELECT ruvector_register_agent(
name := 'code-specialist',
agent_type := 'tool',
capabilities := ARRAY['code-execution', 'debugging', 'testing'],
cost_per_call := 0.001,
avg_latency_ms := 100,
quality_score := 0.90
);
-- List registered agents
SELECT * FROM ruvector_list_agents();
```
### Basic Routing
```sql
-- Route a request to the best agent
SELECT * FROM ruvector_route(
request := 'Write a Python function to calculate Fibonacci numbers',
optimize_for := 'cost' -- or 'latency', 'quality', 'balanced'
);
-- Result:
-- | claude-3-haiku | 0.85 | 0.001 | 400ms |
-- Route with constraints
SELECT * FROM ruvector_route(
request := 'Analyze this complex legal document',
required_capabilities := ARRAY['reasoning', 'analysis'],
max_cost := 0.10,
max_latency_ms := 5000,
min_quality := 0.90
);
-- Multi-agent routing (for complex tasks)
SELECT * FROM ruvector_route_multi(
request := 'Build and deploy a web application',
num_agents := 3,
strategy := 'pipeline' -- or 'parallel', 'ensemble'
);
```
### Semantic Routing
```sql
-- Create semantic routes (like function calling)
SELECT ruvector_create_route(
name := 'customer_support',
description := 'Handle customer support inquiries, complaints, and feedback',
embedding := ruvector_embed('Customer support and help requests'),
target_agent := 'support-agent',
priority := 1
);
SELECT ruvector_create_route(
name := 'technical_docs',
description := 'Answer questions about technical documentation and APIs',
embedding := ruvector_embed('Technical documentation and API reference'),
target_agent := 'docs-agent',
priority := 2
);
-- Semantic route matching
SELECT * FROM ruvector_semantic_route(
query := 'How do I reset my password?',
top_k := 3
);
-- Result:
-- | customer_support | 0.92 | support-agent | 0.95 |
```
### Cost Optimization
```sql
-- Analyze routing costs
SELECT * FROM ruvector_routing_analytics(
time_range := '7 days',
group_by := 'agent'
);
-- Result:
-- | gpt-4 | 1000 | $30.00 | 2.5s | 99.2% |
-- | haiku | 5000 | $1.25 | 0.4s | 98.5% |
-- Optimize budget allocation
SELECT * FROM ruvector_optimize_budget(
monthly_budget := 100.00,
quality_threshold := 0.85,
latency_threshold_ms := 2000
);
-- Auto-route with budget awareness
SELECT * FROM ruvector_route(
request := 'Summarize this article',
budget_remaining := 10.00,
optimize_for := 'quality_per_dollar'
);
```
### Batch Routing
```sql
-- Route multiple requests efficiently
SELECT * FROM ruvector_batch_route(
requests := ARRAY[
'Simple question 1',
'Complex analysis task',
'Code generation request'
],
optimize_for := 'total_cost'
);
-- Classify requests in batch (for preprocessing)
SELECT request_id, ruvector_classify_request(content) AS classification
FROM pending_requests;
```
## Implementation Phases
### Phase 1: FastGRNN Core (Week 1-3)
```rust
// src/routing/fastgrnn.rs
use simsimd::SpatialSimilarity;
/// FastGRNN (Fast Gated Recurrent Neural Network)
/// Lightweight neural network for fast inference
pub struct FastGRNN {
// Gate weights
w_gate: Vec<f32>, // [hidden, input]
u_gate: Vec<f32>, // [hidden, hidden]
b_gate: Vec<f32>, // [hidden]
// Update weights
w_update: Vec<f32>, // [hidden, input]
u_update: Vec<f32>, // [hidden, hidden]
b_update: Vec<f32>, // [hidden]
// Hyperparameters
zeta: f32, // Gate sparsity
nu: f32, // Update sparsity
input_dim: usize,
hidden_dim: usize,
}
impl FastGRNN {
pub fn new(input_dim: usize, hidden_dim: usize) -> Self {
Self {
w_gate: Self::init_weights(hidden_dim, input_dim),
u_gate: Self::init_weights(hidden_dim, hidden_dim),
b_gate: vec![0.0; hidden_dim],
w_update: Self::init_weights(hidden_dim, input_dim),
u_update: Self::init_weights(hidden_dim, hidden_dim),
b_update: vec![0.0; hidden_dim],
zeta: 1.0,
nu: 1.0,
input_dim,
hidden_dim,
}
}
/// Single step forward pass
/// h_t = (ζ * (1 - z_t) + ν) ⊙ tanh(Wx_t + Uh_{t-1} + b_h) + z_t ⊙ h_{t-1}
pub fn step(&self, input: &[f32], hidden: &[f32]) -> Vec<f32> {
// Gate: z = σ(W_z x + U_z h + b_z)
let gate = self.sigmoid(&self.linear_combine(
input, hidden,
&self.w_gate, &self.u_gate, &self.b_gate
));
// Update: h̃ = tanh(W_h x + U_h h + b_h)
let update = self.tanh(&self.linear_combine(
input, hidden,
&self.w_update, &self.u_update, &self.b_update
));
// New hidden: h = (ζ(1-z) + ν) ⊙ h̃ + z ⊙ h
let mut new_hidden = vec![0.0; self.hidden_dim];
for i in 0..self.hidden_dim {
let gate_factor = self.zeta * (1.0 - gate[i]) + self.nu;
new_hidden[i] = gate_factor * update[i] + gate[i] * hidden[i];
}
new_hidden
}
/// Process sequence
pub fn forward(&self, sequence: &[Vec<f32>]) -> Vec<f32> {
let mut hidden = vec![0.0; self.hidden_dim];
for input in sequence {
hidden = self.step(input, &hidden);
}
hidden
}
/// Process single input (common case for routing)
pub fn forward_single(&self, input: &[f32]) -> Vec<f32> {
let hidden = vec![0.0; self.hidden_dim];
self.step(input, &hidden)
}
#[inline]
fn linear_combine(
&self,
input: &[f32],
hidden: &[f32],
w: &[f32],
u: &[f32],
b: &[f32],
) -> Vec<f32> {
let mut result = b.to_vec();
// W @ x
for i in 0..self.hidden_dim {
for j in 0..self.input_dim {
result[i] += w[i * self.input_dim + j] * input[j];
}
}
// U @ h
for i in 0..self.hidden_dim {
for j in 0..self.hidden_dim {
result[i] += u[i * self.hidden_dim + j] * hidden[j];
}
}
result
}
#[inline]
fn sigmoid(&self, x: &[f32]) -> Vec<f32> {
x.iter().map(|&v| 1.0 / (1.0 + (-v).exp())).collect()
}
#[inline]
fn tanh(&self, x: &[f32]) -> Vec<f32> {
x.iter().map(|&v| v.tanh()).collect()
}
}
```
### Phase 2: Route Classifier (Week 4-5)
```rust
// src/routing/classifier.rs
/// Route classifier using FastGRNN + linear head
pub struct RouteClassifier {
fastgrnn: FastGRNN,
classifier_head: Vec<f32>, // [num_classes, hidden_dim]
num_classes: usize,
class_names: Vec<String>,
}
impl RouteClassifier {
/// Classify request to route category
pub fn classify(&self, embedding: &[f32]) -> Vec<(String, f32)> {
// FastGRNN encoding
let hidden = self.fastgrnn.forward_single(embedding);
// Linear classifier
let mut logits = vec![0.0; self.num_classes];
for i in 0..self.num_classes {
for j in 0..hidden.len() {
logits[i] += self.classifier_head[i * hidden.len() + j] * hidden[j];
}
}
// Softmax
let probs = softmax(&logits);
// Return sorted by probability
let mut results: Vec<_> = self.class_names.iter()
.zip(probs.iter())
.map(|(name, &prob)| (name.clone(), prob))
.collect();
results.sort_by(|(_, a), (_, b)| b.partial_cmp(a).unwrap());
results
}
/// Multi-label classification (request may need multiple capabilities)
pub fn classify_capabilities(&self, embedding: &[f32]) -> Vec<(String, f32)> {
let hidden = self.fastgrnn.forward_single(embedding);
// Sigmoid for multi-label
let mut results = Vec::new();
for i in 0..self.num_classes {
let mut logit = 0.0;
for j in 0..hidden.len() {
logit += self.classifier_head[i * hidden.len() + j] * hidden[j];
}
let prob = 1.0 / (1.0 + (-logit).exp());
if prob > 0.5 {
results.push((self.class_names[i].clone(), prob));
}
}
results.sort_by(|(_, a), (_, b)| b.partial_cmp(a).unwrap());
results
}
}
#[pg_extern]
fn ruvector_classify_request(request: &str) -> pgrx::JsonB {
let embedding = get_embedding(request);
let classifier = get_route_classifier();
let classifications = classifier.classify(&embedding);
pgrx::JsonB(serde_json::json!({
"classifications": classifications,
"top_category": classifications.first().map(|(name, _)| name),
"confidence": classifications.first().map(|(_, prob)| prob),
}))
}
```
### Phase 3: Agent Registry (Week 6-7)
```rust
// src/routing/agents/registry.rs
use dashmap::DashMap;
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Agent {
pub name: String,
pub agent_type: AgentType,
pub capabilities: Vec<String>,
pub capability_embedding: Vec<f32>, // Embedding of capabilities for semantic matching
pub cost_model: CostModel,
pub performance: AgentPerformance,
pub metadata: serde_json::Value,
pub active: bool,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum AgentType {
LLM,
Tool,
API,
Human,
Ensemble,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CostModel {
pub cost_per_1k_tokens: Option<f64>,
pub cost_per_call: Option<f64>,
pub cost_per_second: Option<f64>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AgentPerformance {
pub avg_latency_ms: f64,
pub p99_latency_ms: f64,
pub quality_score: f64,
pub success_rate: f64,
pub total_requests: u64,
}
/// Global agent registry
pub struct AgentRegistry {
agents: DashMap<String, Agent>,
capability_index: HnswIndex, // For semantic capability matching
}
impl AgentRegistry {
pub fn register(&self, agent: Agent) -> Result<(), RegistryError> {
// Index capability embedding
let embedding = &agent.capability_embedding;
self.capability_index.insert(&agent.name, embedding);
self.agents.insert(agent.name.clone(), agent);
Ok(())
}
pub fn get(&self, name: &str) -> Option<Agent> {
self.agents.get(name).map(|a| a.clone())
}
pub fn find_by_capability(&self, capability: &str, k: usize) -> Vec<&Agent> {
let embedding = get_embedding(capability);
let results = self.capability_index.search(&embedding, k);
results.iter()
.filter_map(|(name, _)| self.agents.get(name.as_str()).map(|a| a.value()))
.collect()
}
pub fn list_active(&self) -> Vec<Agent> {
self.agents.iter()
.filter(|a| a.active)
.map(|a| a.clone())
.collect()
}
}
#[pg_extern]
fn ruvector_register_agent(
name: &str,
agent_type: &str,
capabilities: Vec<String>,
cost_per_1k_tokens: default!(Option<f64>, "NULL"),
cost_per_call: default!(Option<f64>, "NULL"),
avg_latency_ms: f64,
quality_score: f64,
metadata: default!(Option<pgrx::JsonB>, "NULL"),
) -> bool {
let registry = get_agent_registry();
// Create capability embedding
let capability_text = capabilities.join(", ");
let capability_embedding = get_embedding(&capability_text);
let agent = Agent {
name: name.to_string(),
agent_type: agent_type.parse().unwrap_or(AgentType::LLM),
capabilities,
capability_embedding,
cost_model: CostModel {
cost_per_1k_tokens,
cost_per_call,
cost_per_second: None,
},
performance: AgentPerformance {
avg_latency_ms,
p99_latency_ms: avg_latency_ms * 2.0,
quality_score,
success_rate: 1.0,
total_requests: 0,
},
metadata: metadata.map(|m| m.0).unwrap_or(serde_json::json!({})),
active: true,
};
registry.register(agent).is_ok()
}
```
### Phase 4: Routing Engine (Week 8-9)
```rust
// src/routing/router.rs
pub struct Router {
registry: Arc<AgentRegistry>,
classifier: Arc<RouteClassifier>,
optimizer: Arc<CostOptimizer>,
semantic_routes: Arc<SemanticRoutes>,
}
#[derive(Debug, Clone)]
pub struct RoutingDecision {
pub agent: Agent,
pub confidence: f64,
pub estimated_cost: f64,
pub estimated_latency_ms: f64,
pub reasoning: String,
}
#[derive(Debug, Clone)]
pub struct RoutingConstraints {
pub required_capabilities: Option<Vec<String>>,
pub max_cost: Option<f64>,
pub max_latency_ms: Option<f64>,
pub min_quality: Option<f64>,
pub excluded_agents: Option<Vec<String>>,
}
impl Router {
/// Route request to best agent
pub fn route(
&self,
request: &str,
constraints: &RoutingConstraints,
optimize_for: OptimizationTarget,
) -> Result<RoutingDecision, RoutingError> {
let embedding = get_embedding(request);
// Get candidate agents
let mut candidates = self.get_candidates(&embedding, constraints)?;
if candidates.is_empty() {
return Err(RoutingError::NoSuitableAgent);
}
// Score candidates
let scored: Vec<_> = candidates.iter()
.map(|agent| {
let score = self.score_agent(agent, &embedding, optimize_for);
(agent, score)
})
.collect();
// Select best
let (best_agent, confidence) = scored.into_iter()
.max_by(|(_, a), (_, b)| a.partial_cmp(b).unwrap())
.unwrap();
Ok(RoutingDecision {
agent: best_agent.clone(),
confidence,
estimated_cost: self.estimate_cost(best_agent, request),
estimated_latency_ms: best_agent.performance.avg_latency_ms,
reasoning: format!("Selected {} based on {:?} optimization", best_agent.name, optimize_for),
})
}
fn get_candidates(
&self,
embedding: &[f32],
constraints: &RoutingConstraints,
) -> Result<Vec<Agent>, RoutingError> {
let mut candidates: Vec<_> = self.registry.list_active();
// Filter by required capabilities
if let Some(required) = &constraints.required_capabilities {
candidates.retain(|a| {
required.iter().all(|cap| a.capabilities.contains(cap))
});
}
// Filter by cost
if let Some(max_cost) = constraints.max_cost {
candidates.retain(|a| {
a.cost_model.cost_per_1k_tokens.unwrap_or(0.0) <= max_cost ||
a.cost_model.cost_per_call.unwrap_or(0.0) <= max_cost
});
}
// Filter by latency
if let Some(max_latency) = constraints.max_latency_ms {
candidates.retain(|a| a.performance.avg_latency_ms <= max_latency);
}
// Filter by quality
if let Some(min_quality) = constraints.min_quality {
candidates.retain(|a| a.performance.quality_score >= min_quality);
}
// Filter excluded
if let Some(excluded) = &constraints.excluded_agents {
candidates.retain(|a| !excluded.contains(&a.name));
}
Ok(candidates)
}
fn score_agent(
&self,
agent: &Agent,
request_embedding: &[f32],
optimize_for: OptimizationTarget,
) -> f64 {
// Capability match score
let capability_sim = cosine_similarity(request_embedding, &agent.capability_embedding);
match optimize_for {
OptimizationTarget::Cost => {
let cost = agent.cost_model.cost_per_1k_tokens.unwrap_or(0.01);
capability_sim * (1.0 / (1.0 + cost))
}
OptimizationTarget::Latency => {
let latency_factor = 1.0 / (1.0 + agent.performance.avg_latency_ms / 1000.0);
capability_sim * latency_factor
}
OptimizationTarget::Quality => {
capability_sim * agent.performance.quality_score
}
OptimizationTarget::Balanced => {
let cost = agent.cost_model.cost_per_1k_tokens.unwrap_or(0.01);
let cost_factor = 1.0 / (1.0 + cost);
let latency_factor = 1.0 / (1.0 + agent.performance.avg_latency_ms / 1000.0);
let quality = agent.performance.quality_score;
capability_sim * (0.3 * cost_factor + 0.3 * latency_factor + 0.4 * quality)
}
OptimizationTarget::QualityPerDollar => {
let cost = agent.cost_model.cost_per_1k_tokens.unwrap_or(0.01);
capability_sim * agent.performance.quality_score / (cost + 0.001)
}
}
}
fn estimate_cost(&self, agent: &Agent, request: &str) -> f64 {
let estimated_tokens = (request.len() / 4) as f64; // Rough estimate
if let Some(cost_per_1k) = agent.cost_model.cost_per_1k_tokens {
cost_per_1k * estimated_tokens / 1000.0
} else if let Some(cost_per_call) = agent.cost_model.cost_per_call {
cost_per_call
} else {
0.0
}
}
}
#[derive(Debug, Clone, Copy)]
pub enum OptimizationTarget {
Cost,
Latency,
Quality,
Balanced,
QualityPerDollar,
}
#[pg_extern]
fn ruvector_route(
request: &str,
optimize_for: default!(&str, "'balanced'"),
required_capabilities: default!(Option<Vec<String>>, "NULL"),
max_cost: default!(Option<f64>, "NULL"),
max_latency_ms: default!(Option<f64>, "NULL"),
min_quality: default!(Option<f64>, "NULL"),
) -> pgrx::JsonB {
let router = get_router();
let constraints = RoutingConstraints {
required_capabilities,
max_cost,
max_latency_ms,
min_quality,
excluded_agents: None,
};
let target = match optimize_for {
"cost" => OptimizationTarget::Cost,
"latency" => OptimizationTarget::Latency,
"quality" => OptimizationTarget::Quality,
"quality_per_dollar" => OptimizationTarget::QualityPerDollar,
_ => OptimizationTarget::Balanced,
};
match router.route(request, &constraints, target) {
Ok(decision) => pgrx::JsonB(serde_json::json!({
"agent_name": decision.agent.name,
"confidence": decision.confidence,
"estimated_cost": decision.estimated_cost,
"estimated_latency_ms": decision.estimated_latency_ms,
"reasoning": decision.reasoning,
})),
Err(e) => pgrx::JsonB(serde_json::json!({
"error": format!("{:?}", e),
})),
}
}
```
### Phase 5: Semantic Routes (Week 10-11)
```rust
// src/routing/semantic_routes.rs
pub struct SemanticRoutes {
routes: DashMap<String, SemanticRoute>,
index: HnswIndex,
}
#[derive(Debug, Clone)]
pub struct SemanticRoute {
pub name: String,
pub description: String,
pub embedding: Vec<f32>,
pub target_agent: String,
pub priority: i32,
pub conditions: Option<RouteConditions>,
}
#[derive(Debug, Clone)]
pub struct RouteConditions {
pub time_range: Option<(chrono::NaiveTime, chrono::NaiveTime)>,
pub user_tier: Option<Vec<String>>,
pub rate_limit: Option<u32>,
}
impl SemanticRoutes {
pub fn add_route(&self, route: SemanticRoute) {
self.index.insert(&route.name, &route.embedding);
self.routes.insert(route.name.clone(), route);
}
pub fn match_route(&self, query_embedding: &[f32], k: usize) -> Vec<(SemanticRoute, f32)> {
let results = self.index.search(query_embedding, k);
results.iter()
.filter_map(|(name, score)| {
self.routes.get(name.as_str())
.map(|r| (r.clone(), *score))
})
.collect()
}
}
#[pg_extern]
fn ruvector_create_route(
name: &str,
description: &str,
target_agent: &str,
priority: default!(i32, 0),
embedding: default!(Option<Vec<f32>>, "NULL"),
) -> bool {
let routes = get_semantic_routes();
let embedding = embedding.unwrap_or_else(|| get_embedding(description));
let route = SemanticRoute {
name: name.to_string(),
description: description.to_string(),
embedding,
target_agent: target_agent.to_string(),
priority,
conditions: None,
};
routes.add_route(route);
true
}
#[pg_extern]
fn ruvector_semantic_route(
query: &str,
top_k: default!(i32, 3),
) -> TableIterator<'static, (
name!(route_name, String),
name!(similarity, f32),
name!(target_agent, String),
name!(confidence, f32),
)> {
let routes = get_semantic_routes();
let embedding = get_embedding(query);
let matches = routes.match_route(&embedding, top_k as usize);
let results: Vec<_> = matches.into_iter()
.map(|(route, similarity)| {
let confidence = similarity * (route.priority as f32 + 1.0) / 10.0;
(route.name, similarity, route.target_agent, confidence.min(1.0))
})
.collect();
TableIterator::new(results)
}
```
### Phase 6: Cost Optimizer (Week 12)
```rust
// src/routing/cost_optimizer.rs
pub struct CostOptimizer {
budget_tracker: BudgetTracker,
usage_history: UsageHistory,
}
#[derive(Debug, Clone)]
pub struct BudgetAllocation {
pub agent_budgets: HashMap<String, f64>,
pub total_budget: f64,
pub period: chrono::Duration,
}
impl CostOptimizer {
/// Optimize budget allocation across agents
pub fn optimize_budget(
&self,
total_budget: f64,
quality_threshold: f64,
latency_threshold: f64,
period_days: i64,
) -> BudgetAllocation {
let agents = get_agent_registry().list_active();
let history = self.usage_history.get_period(period_days);
// Calculate value score for each agent
let agent_values: HashMap<String, f64> = agents.iter()
.filter(|a| {
a.performance.quality_score >= quality_threshold &&
a.performance.avg_latency_ms <= latency_threshold
})
.map(|a| {
let historical_usage = history.get(&a.name).map(|h| h.request_count).unwrap_or(1);
let quality = a.performance.quality_score;
let cost_efficiency = 1.0 / (a.cost_model.cost_per_1k_tokens.unwrap_or(0.01) + 0.001);
let value = quality * cost_efficiency * (historical_usage as f64).ln();
(a.name.clone(), value)
})
.collect();
// Allocate budget proportionally to value
let total_value: f64 = agent_values.values().sum();
let agent_budgets: HashMap<String, f64> = agent_values.iter()
.map(|(name, value)| {
let allocation = (value / total_value) * total_budget;
(name.clone(), allocation)
})
.collect();
BudgetAllocation {
agent_budgets,
total_budget,
period: chrono::Duration::days(period_days),
}
}
/// Check if request fits within budget
pub fn check_budget(&self, agent: &str, estimated_cost: f64) -> bool {
self.budget_tracker.remaining(agent) >= estimated_cost
}
/// Record usage
pub fn record_usage(&self, agent: &str, actual_cost: f64, success: bool, latency_ms: f64) {
self.budget_tracker.deduct(agent, actual_cost);
self.usage_history.record(agent, actual_cost, success, latency_ms);
}
}
#[pg_extern]
fn ruvector_optimize_budget(
monthly_budget: f64,
quality_threshold: default!(f64, 0.8),
latency_threshold_ms: default!(f64, 5000.0),
) -> pgrx::JsonB {
let optimizer = get_cost_optimizer();
let allocation = optimizer.optimize_budget(
monthly_budget,
quality_threshold,
latency_threshold_ms,
30,
);
pgrx::JsonB(serde_json::json!({
"allocations": allocation.agent_budgets,
"total_budget": allocation.total_budget,
"period_days": 30,
}))
}
#[pg_extern]
fn ruvector_routing_analytics(
time_range: default!(&str, "'7 days'"),
group_by: default!(&str, "'agent'"),
) -> TableIterator<'static, (
name!(agent, String),
name!(total_requests, i64),
name!(total_cost, f64),
name!(avg_latency_ms, f64),
name!(success_rate, f64),
)> {
let optimizer = get_cost_optimizer();
let days = parse_time_range(time_range);
let stats = optimizer.usage_history.aggregate(days, group_by);
TableIterator::new(stats)
}
```
## Benchmarks
| FastGRNN step | 768-dim | 45 | 1KB |
| Route classification | 768-dim | 120 | 4KB |
| Semantic route match (1K routes) | 768-dim | 250 | 8KB |
| Full routing decision | 768-dim | 500 | 16KB |
## Dependencies
```toml
[dependencies]
# Link to ruvector-tiny-dancer
ruvector-tiny-dancer-core = { path = "../ruvector-tiny-dancer-core", optional = true }
# SIMD
simsimd = "5.9"
# Time handling
chrono = "0.4"
# Concurrent collections
dashmap = "6.0"
```
## Feature Flags
```toml
[features]
routing = []
routing-fastgrnn = ["routing"]
routing-semantic = ["routing", "index-hnsw"]
routing-optimizer = ["routing"]
routing-all = ["routing-fastgrnn", "routing-semantic", "routing-optimizer"]
```