Rebrand card to Merino-Pro-4bit

README.md

@@ -1,85 +1,47 @@
 ---
 license: other
 license_name: baa-proprietary
-library_name: baa-embedding-reranker
-tags: [embeddings, reranker, retrieval, rag, cross-encoder, bi-encoder]
+library_name: sentence-transformers
+tags:
+- retrieval
+- embeddings
+- reranker
+- cross-encoder
+- rag
+- sentence-similarity
+pipeline_tag: sentence-similarity
 ---
 
-# baa-ai-Embedding-Reranker-v1-4bit
+# baa.ai · Merino-Pro-4bit
 
-A **single package that does both embedding (retrieval) and reranking** for RAG / search pipelines,
-by **BAA AI (Black Sheep AI)**. The bi-encoder embedder and cross-encoder reranker share one
-XLM-RoBERTa-large word-embedding table (stored once). This is the **4-bit** build (group-64 int4 Linear weights; ~2x smaller download, same hit@3).
+**The premium unified retrieval model — bi-encoder embedding *and* cross-encoder reranking in one package, over a single shared word-embedding table.** A 1024-dimensional multilingual model, by BAA AI (Black Sheep AI). ~872M params, 4-bit quantized (~0.5 GB).
 
-- **Embed (bi-encoder):** 1024-d, L2-normalized. Prefix queries with `"query: "`.
-- **Rerank (cross-encoder):** relevance score per (query, document) pair.
-- One class, two methods: `.embed(...)` and `.rerank(...)`.
+## Get the optimal model for *your* data
 
-## Install
-```bash
-pip install -r requirements.txt
-```
-The package is self-contained — the loader lives in `modeling_baa.py` and reconstructs the model from the
-files in this folder. Works on CPU, Apple Silicon (MPS), and CUDA.
-
-## Load into memory
-```python
-from modeling_baa import BaaEmbeddingReranker
+Merino-Pro-4bit is baa.ai's flagship default. But the best embedder + reranker is **corpus-specific** — the ideal choice depends on your documents and your notion of relevance. **baa.ai offers exclusive tooling that identifies the optimal embedding and reranking models for your specific data**, so you ship the smallest models that maximize document recovery on your corpus. For a tailored recommendation, **reach out to baa.ai**.
 
-# point at the downloaded folder (or "." if you cd into it). Auto-selects mps/cuda/cpu.
-model = BaaEmbeddingReranker("path/to/baa-ai-Embedding-Reranker-v1-4bit")
-# force a device if you want: BaaEmbeddingReranker("...", device="cpu")
-```
+## What it is
 
-## Embed — dense retrieval
-```python
-import numpy as np
+A two-role retrieval model over a **shared input word-embedding matrix** (~256M params, stored once). The bi-encoder embedder and cross-encoder reranker are both built on the `xlm-roberta-large` backbone and **co-trained** to share a single word-embedding table at **no quality loss**, while each role keeps its native layers and head. 4-bit weight quantization is lossless on this stack (the embedder is the limiter; rerank tolerates lower bits).
 
-docs = ["Paris is the capital of France.", "The mitochondria is the powerhouse of the cell."]
-doc_vecs = model.embed(docs)                       # (2, 1024) float32, L2-normalized
-q_vec    = model.embed(["What is the capital of France?"], is_query=True)[0]   # note is_query=True
+- **Embed role:** bi-encoder, 1024-d, L2-normalized. Prepend `"query: "` to queries.
+- **Rerank role:** cross-encoder, single relevance logit per (query, document) pair.
+- **Router:** call `.embed(...)` or `.rerank(...)`.
 
-scores = doc_vecs @ q_vec                          # cosine (vectors are normalized)
-top = int(np.argmax(scores))
-print("best doc:", docs[top], "score:", float(scores[top]))
-```
+## Usage
 
-## Rerank — order candidates for a query
 ```python
-query = "What is the capital of France?"
-candidates = ["Paris is the capital of France.",
-              "Berlin is the capital of Germany.",
-              "France is in western Europe."]
+from modeling_baa import BaaEmbeddingReranker   # included in this repo
 
-ranked = model.rerank(query, candidates, top_k=3)  # [(doc, score), ...] best-first
-for doc, score in ranked:
-    print(round(score, 2), doc)
+m = BaaEmbeddingReranker("baa-ai/Merino-Pro-4bit")
+qv = m.embed(["my query"], is_query=True)[0]     # 1024-d normalized
+dv = m.embed(["doc a", "doc b"])
+ranked = m.rerank("my query", ["doc a", "doc b"], top_k=10)   # [(doc, score), ...]
 ```
 
-## End-to-end RAG retrieval (embed -> shortlist -> rerank)
-```python
-import numpy as np
-
-# 1) index your corpus once
-corpus = ["...doc 1...", "...doc 2...", "...", "...doc N..."]
-corpus_vecs = model.embed(corpus)                  # (N, 1024)
-
-def search(query, k_dense=50, k_final=5):
-    qv = model.embed([query], is_query=True)[0]
-    # 2) dense shortlist
-    sims = corpus_vecs @ qv
-    shortlist = np.argsort(-sims)[:k_dense]
-    # 3) rerank the shortlist
-    cand = [corpus[i] for i in shortlist]
-    return model.rerank(query, cand, top_k=k_final)
-
-print(search("your question here"))
-```
+## License & attribution
 
-## Performance
-Validated on a 450-query holdout: hit@3 = **0.9511** (fp16) / **0.9556** (4-bit) — quantization is free here
-because the cross-encoder absorbs it. This is the **4-bit** build (group-64 int4 Linear weights; ~2x smaller download, same hit@3).
+- **BAA Contributions** (shared-embedding architecture, router/loader code, packaging, weights, docs) are **proprietary to BAA AI (Black Sheep AI)** — see `LICENSE`.
+- Incorporates the `xlm-roberta-large` backbone under the **MIT License** — see `LICENSE-xlm-roberta-large.txt`.
 
-## License
-- **BAA Contributions** (architecture, loader, packaging, weights, docs): **proprietary** — see `LICENSE`.
-- Backbone `xlm-roberta-large`: **MIT** — see `LICENSE-xlm-roberta-large.txt`.
+© 2026 BAA AI (Black Sheep AI) — baa.ai. Provided "as is" without warranty.