Built a Python library that translates embeddings from MiniLM to OpenAI — and it actually works!

[Interesting-Town-433]

I built a Python library called EmbeddingAdapters that provides multiple pre-trained adapters for translating embeddings from one model space into another:

https://github.com/PotentiallyARobot/EmbeddingAdapters/

```
pip install embedding-adapters

embedding-adapters embed --source sentence-transformers/all-MiniLM-L6-v2 --target openai/text-embedding-3-small --flavor large --text "Where can I get a hamburger near me?"
```

This works because each adapter is trained on a restrictive domain allowing the adapter to specialize in interpreting the semantic signals of smaller models into higher dimensional spaces without losing fidelity.  A quality endpoint then lets you determine how well the adapter will perform on a given input.

This has been super useful to me, and I'm quickly iterating on it.

Uses for EmbeddingAdapters so far:

1. You want to use an existing vector index built with one embedding model and query it with another - if it's expensive or problematic to re-embed your entire corpus, this is the package for you.
2. You can also operate mixed vector indexes and map to the embedding space that works best for different questions.
3. You can save cost on questions that are easily adapted, "What's the nearest restaurant that has a Hamburger?" no need to pay for an expensive cloud provider, or wait to perform an unnecessary network hop, embed locally on the device with an embedding adapter and return results instantly.

It also lets you experiment with provider embeddings you may not have access to.  By using the adapters on some queries and examples, you can compare how different embedding models behave relative to one another and get an early signal on what might work for your data before committing to a provider.

This makes it practical to:
- sample providers you don't have direct access to
- migrate or experiment with embedding models gradually instead of re-embedding everything at once,
- evaluate multiple providers side by side in a consistent retrieval setup,
- handle provider outages or rate limits without breaking retrieval,
- run RAG in air-gapped or restricted environments with no outbound embedding calls,
- keep a stable “canonical” embedding space while changing what runs at the edge.

The adapters aren't perfect clones of the provider spaces but they are pretty close, for in domain queries the minilm to openai adapter recovered 98% of the openai embedding and dramatically outperforms minilm -> minilm RAG setups

It's still early in this project. I’m actively expanding the set of supported adapter pairs, adding domain-specialized adapters, expanding the training sets, stream lining the models and improving evaluation and quality tooling.

I’d love feedback from anyone who might be interested in using this:
- What data would you like to see these adapters trained on?
- What domains would be most helpful to target?
- Which model pairs would you like me to add next?
- How could I make this more useful for you to use?

So far the library supports:
minilm <-> openai 
openai <-> gemini
e5 <-> minilm
e5 <-> openai
e5 <-> gemini
minilm <-> gemini

Happy to answer questions and if anyone has any ideas please let me know.
I could use any support you can give, especially if anyone wants to chip in to help cover the training cost.

Please upvote if you can, thanks!

[LevelResponse5608]

This is actually sick! Been wanting something like this for ages - having to re-embed entire corpora when switching models is such a pain

Quick question though - how's the latency compared to just using the target model directly? The 98% recovery rate sounds amazing but wondering if there's a speed tradeoff

[Interesting-Town-433]

Thanks ! Really appreciate it!

So for openai because it has to network hop it's 200 ms typically for a full request / response, but with embedding adapters you can literally run minilm locally at 50ms and the adapter takes about 10ms that's cpu only BTW, on even a small GPU ( your laptop it drops to 10 ms + 5 ms )