Muninn-small

Muninn-small is a 47M-parameter multilingual retriever for natural-language-query → code-function retrieval, with an 8,192-token context and 384-dimensional embeddings.

It is the efficient Muninn tier, trained from ibm-granite/granite-embedding-small-english-r2 with a ModernBERT encoder.

Usage

from sentence_transformers import SentenceTransformer

model = SentenceTransformer("BrokkAI/Muninn-small")
model.max_seq_length = 8192

queries = ["Where is retry backoff calculated for failed HTTP requests?"]
documents = [
    "src/net/client.py/HttpClient/retry_delay\n"
    "class HttpClient:def retry_delay(self, attempt):\n"
    "    return min(60, 2 ** attempt)"
]

query_embeddings = model.encode(queries, prompt_name="query", normalize_embeddings=True)
document_embeddings = model.encode(
    documents, prompt_name="document", normalize_embeddings=True
)
scores = model.similarity(query_embeddings, document_embeddings)
print(scores)

The exact prompts used during training and evaluation are:

query:    Given a GitHub issue, retrieve code that must be changed to fix it.
          Query: 
document: Passage: Code chunk from repository.

The query prompt literally says “GitHub issue” because that is the trained prefix. Quarry queries are synthetic natural-language behavioral descriptions, not raw issue text. Keep the prefix unchanged at inference time even when the input is another kind of natural- language code-search query.

Document format

Quarry results use the header format produced by swerank_document_text() before the document prompt is applied. For a free function:

{path}/{function_name}
{source}

For a class method:

{path}/{ClassName}/{function_name}
class {ClassName}:{source}

The worked usage example above is therefore the exact representation of a method named HttpClient.retry_delay in src/net/client.py.

Quarry results

Quarry contains 6,525 synthetic behavioral queries over real repository revisions. The metric is strict all-gold micro recall@k: for each query, |gold ∩ top-k| / |gold|, followed by a flat mean over queries. Models use their native dimensions and the header document format above.

We measured every row ourselves with the Quarry harness. At 47M parameters, Muninn-small beats its own base by 4.6 points at recall@5 and matches SweRank-Small (137M, Python-only training) at recall@20 while running at roughly a third of its size.

Other benchmarks

† marks published numbers (SweRank paper for the localization benchmarks; the CoIR leaderboard and the Qwen3-Embedding paper elsewhere). Unmarked rows are our measurements on the same protocol as the corresponding published numbers.

SWE-Bench-Lite localization — 274 Python issues, function-level accuracy:

LocBench — 560 Python issues, function-level accuracy:

CoIR text-to-code — NDCG@10:

CodeSearchNet — mean NDCG@10 over six languages (Python, JavaScript, Go, Ruby, Java, PHP; 1,000 queries per language):

Muninn-small is specialized for repository-scale function retrieval; the APPS number shows it is not a general text-to-code model for competitive-programming-style queries.

Languages

C, C++, C#, Go, Java, JavaScript, PHP, Python, Rust, Scala, and TypeScript.

License and attribution

Muninn-small is released under the Apache License 2.0. It is derived from ibm-granite/granite-embedding-small-english-r2, also released under Apache-2.0. See LICENSE for the full license text.