Publish AgentWeave Router MiniLM from 3791f8e

README.md

@@ -0,0 +1,161 @@
+---
+license: apache-2.0
+library_name: sentence-transformers
+pipeline_tag: feature-extraction
+base_model: sentence-transformers/all-MiniLM-L6-v2
+tags:
+  - agentweave
+  - agentic-ai
+  - tool-routing
+  - semantic-routing
+  - function-calling
+  - cpu
+  - minilm
+  - sentence-transformers
+  - pre-inference-routing
+language:
+  - en
+---
+
+# AgentWeave Router MiniLM 🧭
+
+> **Route before you reason.**
+
+A lightweight, CPU-first semantic capability router for **AgentWeave**. It uses `sentence-transformers/all-MiniLM-L6-v2` as a frozen embedding encoder and ranks route prototypes with cosine similarity before downstream model inference.
+
+This repository is intentionally small: it publishes the AgentWeave routing configuration, route prototypes, and executable router code while reusing the upstream MiniLM encoder at runtime instead of copying its weights.
+
+## Why this exists
+
+Tool-rich agents can expose large action spaces to a language model. AgentWeave explores a complementary systems strategy: reduce the candidate action space *before* model reasoning. This model repository provides an experimental semantic routing companion to AgentWeave's default deterministic routing path.
+
+### Route families
+
+- 🔎 `research`
+- 📚 `retrieval`
+- 🧠 `analysis`
+- 💻 `coding`
+- 🗺️ `planning`
+- ✅ `verification`
+- 📝 `summarization`
+- 📊 `data_analysis`
+
+## Architecture
+
+```text
+Task / user request
+        │
+        ▼
+all-MiniLM-L6-v2
+  384-d embedding
+        │
+        ├──────────────┐
+        ▼              ▼
+query vector     route prototypes
+        │              │
+        └──── cosine ──┘
+               │
+               ▼
+        ranked route set
+               │
+               ▼
+      downstream AgentWeave
+```
+
+**No fine-tuning is claimed.** This is a prototype-based semantic router built on a frozen MiniLM encoder. Similarity scores are ranking signals, **not calibrated probabilities**.
+
+## Quick start
+
+```bash
+pip install -r requirements.txt
+python router.py "research the latest protocol changes, verify the sources, and summarize the findings"
+```
+
+Example output shape:
+
+```json
+[
+  {"route": "research", "score": 0.0},
+  {"route": "verification", "score": 0.0},
+  {"route": "summarization", "score": 0.0}
+]
+```
+
+The numeric values above are placeholders showing the response schema; actual scores are computed locally from MiniLM embeddings.
+
+## Python usage
+
+```python
+from router import AgentWeaveSemanticRouter
+
+router = AgentWeaveSemanticRouter()
+routes = router.route(
+    "inspect this code, identify correctness risks, and propose a fix",
+    top_k=3,
+)
+print(routes)
+```
+
+## CPU-first design
+
+The router is designed for lightweight local execution:
+
+- frozen MiniLM encoder
+- no text generation
+- no external inference API required
+- normalized embeddings + cosine ranking
+- small route-prototype file
+
+The first run downloads the upstream MiniLM encoder. Subsequent runs can use the local Hugging Face cache.
+
+## Relationship to AgentWeave
+
+AgentWeave's documented default BYOM routing path is deterministic and provider-neutral. This MiniLM router is an **experimental semantic companion**, not a replacement for the default router and not the source of AgentWeave's published deterministic-router benchmark claims.
+
+Relevance routing also does **not** grant permission to execute a tool. Policy filtering, scope controls, and authorization remain separate boundaries in AgentWeave.
+
+## Files
+
+| File | Purpose |
+|---|---|
+| `router.py` | CPU semantic router implementation |
+| `route_prototypes.json` | Human-readable capability prototypes |
+| `config.json` | Base model and routing configuration |
+| `requirements.txt` | Minimal runtime dependencies |
+
+## Intended use
+
+Good fits:
+
+- pre-inference capability routing
+- agent/tool candidate reduction experiments
+- CPU routing demos
+- semantic route exploration
+- research comparisons with deterministic routing
+
+Not intended as:
+
+- a calibrated confidence model
+- an authorization engine
+- a safety classifier
+- a replacement for downstream function-calling evaluation
+
+## Limitations
+
+- English-focused route prototypes
+- prototype wording influences ranking
+- route scores are cosine similarities, not probabilities
+- the route taxonomy is intentionally compact
+- domain-specific tools may need custom prototypes
+
+## Source
+
+AgentWeave source code and research artifacts are maintained at:
+
+`https://github.com/sauravsingla/AgentWeave`
+
+The Hugging Face Space provides an interactive companion experience under the same project name.
+
+## License
+
+Apache-2.0. The upstream `sentence-transformers/all-MiniLM-L6-v2` model is loaded separately at runtime and remains subject to its own model card and license terms.

config.json

@@ -0,0 +1,11 @@
+{
+  "model_type": "agentweave_semantic_router",
+  "architecture": "prototype_cosine_router",
+  "base_model": "sentence-transformers/all-MiniLM-L6-v2",
+  "embedding_dimension": 384,
+  "similarity": "cosine",
+  "normalize_embeddings": true,
+  "default_top_k": 3,
+  "training": "none; prototype-based semantic routing",
+  "version": "0.1.0"
+}

requirements.txt

@@ -0,0 +1,2 @@
+sentence-transformers>=3.0.0
+numpy>=1.26.0

route_prototypes.json

@@ -0,0 +1,42 @@
+{
+  "research": [
+    "research a technical topic using authoritative sources",
+    "compare alternatives and gather supporting evidence",
+    "investigate prior work, documentation, or literature"
+  ],
+  "retrieval": [
+    "retrieve facts, records, documents, or external information",
+    "search for relevant evidence before answering",
+    "look up documentation, references, or source material"
+  ],
+  "analysis": [
+    "analyze evidence, systems, tradeoffs, risks, or behavior",
+    "reason over multiple inputs and identify important patterns",
+    "evaluate a technical claim or architecture"
+  ],
+  "coding": [
+    "write, inspect, debug, or modify source code",
+    "build a prototype or implementation",
+    "test code and identify correctness problems"
+  ],
+  "planning": [
+    "create an implementation plan, workflow, or sequence of actions",
+    "design a migration, experiment, or engineering approach",
+    "organize tasks and optimize the execution path"
+  ],
+  "verification": [
+    "verify a claim, result, constraint, or implementation",
+    "independently validate evidence or conclusions",
+    "check consistency, correctness, compliance, or reliability"
+  ],
+  "summarization": [
+    "summarize findings into a concise structured response",
+    "compress multiple analyses while preserving key conclusions",
+    "produce a clear synthesis of technical information"
+  ],
+  "data_analysis": [
+    "analyze a dataset and identify trends or anomalies",
+    "inspect metrics, measurements, tables, or experimental results",
+    "perform quantitative analysis and summarize findings"
+  ]
+}

router.py

@@ -0,0 +1,84 @@
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+from typing import Dict, List
+
+import numpy as np
+from sentence_transformers import SentenceTransformer
+
+
+ROOT = Path(__file__).resolve().parent
+
+
+class AgentWeaveSemanticRouter:
+    """Prototype-based semantic capability router built on MiniLM embeddings.
+
+    This is an experimental semantic companion to AgentWeave's default
+    deterministic routing path. It does not replace AgentWeave policy,
+    authorization, or execution controls.
+    """
+
+    def __init__(
+        self,
+        config_path: str | Path = ROOT / "config.json",
+        prototypes_path: str | Path = ROOT / "route_prototypes.json",
+    ) -> None:
+        self.config = json.loads(Path(config_path).read_text(encoding="utf-8"))
+        self.prototypes: Dict[str, List[str]] = json.loads(
+            Path(prototypes_path).read_text(encoding="utf-8")
+        )
+        self.model = SentenceTransformer(self.config["base_model"], device="cpu")
+
+        texts: List[str] = []
+        labels: List[str] = []
+        for label, examples in self.prototypes.items():
+            for example in examples:
+                labels.append(label)
+                texts.append(example)
+
+        self._prototype_labels = labels
+        self._prototype_embeddings = self.model.encode(
+            texts,
+            normalize_embeddings=bool(self.config.get("normalize_embeddings", True)),
+            convert_to_numpy=True,
+            show_progress_bar=False,
+        )
+
+    def route(self, query: str, top_k: int | None = None) -> List[dict]:
+        if not query or not query.strip():
+            raise ValueError("query must be a non-empty string")
+
+        top_k = int(top_k or self.config.get("default_top_k", 3))
+        query_embedding = self.model.encode(
+            [query],
+            normalize_embeddings=bool(self.config.get("normalize_embeddings", True)),
+            convert_to_numpy=True,
+            show_progress_bar=False,
+        )[0]
+
+        similarities = self._prototype_embeddings @ query_embedding
+        best_by_label: Dict[str, float] = {}
+        for label, score in zip(self._prototype_labels, similarities):
+            best_by_label[label] = max(best_by_label.get(label, -1.0), float(score))
+
+        ranked = sorted(best_by_label.items(), key=lambda item: item[1], reverse=True)
+        return [
+            {"route": label, "score": round(score, 6)}
+            for label, score in ranked[: max(1, min(top_k, len(ranked)))]
+        ]
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="AgentWeave MiniLM semantic router")
+    parser.add_argument("query", help="Task or request to route")
+    parser.add_argument("--top-k", type=int, default=None, help="Number of routes to return")
+    args = parser.parse_args()
+
+    router = AgentWeaveSemanticRouter()
+    print(json.dumps(router.route(args.query, args.top_k), indent=2))
+
+
+if __name__ == "__main__":
+    main()