Multilingual embedding and reranking,
without your texts leaving Europe.
AgileV turns text into vectors for semantic search and RAG systems. Open model bge-m3 (1024 dimensions, more than 100 languages) running on our own servers in Europe. API compatible with OpenAI's: you change an address, not your code.
API documentationRequest a licenceService status: checking…
Why AgileV
Data sovereignty
Texts are processed and immediately forgotten: no content ever reaches a log, a database or a file. All that is left of your traffic is numeric counters. No non-EU providers, no training on your data.
OpenAI compatible
The /v1/embeddings endpoint uses the same request and response format: it works with the clients and frameworks you already use.
Genuinely multilingual
bge-m3 covers Italian, English and more than 100 languages with the same quality, for long texts too, up to 8,000 tokens.
Keys you control
Every key has a scope, a rate limit and a quota. You can see your own usage and revoke a key whenever you want.
Reranking included
Reorder search results by relevance with a dedicated model: more precision for your RAG without touching your index.
Compact vectors
You can ask for them in int8 (a quarter of the space, cosine ≥ 0.997 against the full format) or binary (1/32). Your vector database costs less.
Count before you spend
The /v1/tokenize endpoint tells you how many tokens a text takes without consuming quota: estimate the cost before you send anything.
Predictable costs
A price per million characters processed, with no surprises. Free internal plan for the products of the Agile suite.
The API in thirty seconds
Base URL: https://api.agilev.agile.software · Authentication: Authorization: Bearer <key>
curl https://api.agilev.agile.software/v1/embeddings \
-H "Authorization: Bearer $AGILEV_KEY" \
-H "Content-Type: application/json" \
-d '{"model":"agilev-m3","input":["Il contratto scade il 30 settembre","Quando finisce l'accordo?"]}'
# response (OpenAI format)
{"object":"list","model":"agilev-m3",
"data":[{"object":"embedding","index":0,"embedding":[0.0109,0.0272,…]},
{"object":"embedding","index":1,"embedding":[…]}],
"usage":{"prompt_tokens":23,"total_tokens":23,"chars":92,"truncated_texts":0}}
# reranking: reorder the candidates against the question
curl https://api.agilev.agile.software/v1/rerank \
-H "Authorization: Bearer $AGILEV_KEY" -H "Content-Type: application/json" \
-d '{"model":"agilev-rerank","query":"scadenza del contratto","documents":["…","…"],"top_n":3}'
The example texts are in Italian on purpose: it is the same request you will find on the Italian page, and the model treats every language alike.
With the OpenAI library it is enough to set base_url="https://api.agilev.agile.software/v1" and model="agilev-m3".
One piece of advice worth more than any optimisation of ours: reuse the HTTP connection. Processing takes about 100 ms, but a request seen from the outside takes 370: the difference is the TLS handshake, and you pay it on every new connection. A client kept alive pays it once.
→ Full API documentation: every parameter, the error codes, the limits and the examples in curl, Python and PHP.
Compared with Voyage and OpenAI
An honest comparison starts with a rule: AgileV's numbers are ours and measured, and each one has the benchmark that produced it. The other providers' numbers were not measured by us, and never will be: measuring a provider means sending it texts, and here texts never leave. So the right-hand column only holds things anyone can check for themselves — vector sizes, where the model runs, how you are billed — and never a measurement of theirs passed off as ours.
| AgileV, measured by us | Voyage / OpenAI | |
|---|---|---|
| Where your texts are processed | On our own servers, inside the European Union. | On the provider's servers, in the regions their contract allows: you read that, we do not tell you what is in it. |
| What is left of your texts | Nothing. No text in logs, in the database or in files: only counters. It is not a promise written on a page, it is a test in our suite that fails if a text shows up anywhere. | Whatever their contract says. |
| Vector size | 1024. | voyage-3: 1024 · voyage-3-lite: 512 · text-embedding-3-small: 1536. We already write this in our documentation, under «Migrating from Voyage or OpenAI». |
| Switching without rebuilding the index | Our previous service and this one return the same vector for the same sentence: cosine 1.0. Whoever came from there re-indexed nothing. | A different model means vectors that cannot be compared: the index is rebuilt from scratch. That holds for anyone changing model, us included. |
| How long it takes | 84 ms for one sentence, 114 ms for two, pure inference. From outside that becomes 0.37 s, and 250 ms of it is TLS and proxy: reuse the connection and you pay it once. It is the advice worth more than any optimisation of ours, and we tell you instead of taking credit for it. | It also depends on how far their server is from yours: that is a measurement you are better off taking yourself, where your code runs. |
| Retrieval quality | On our evaluation set (26 passages of public legislation, 20 queries): R@1 0.825 and nDCG@10 0.907 with dense; 0.925 and 0.968 with the dense + lexical hybrid, which we serve in the same call. | We have not measured it, for the reason in the first row of this table. And the comparison that counts is another one: take a trial licence and measure both on your corpus, the only one you will actually work on. |
| How what you pay is counted | In characters: you count them yourself, in any language, with no tokenizer and without having to take our word for it. | In tokens. To put the two price lists side by side you need the ratio between the two units: on our Italian texts we measured 4.4 characters per token. |
| The model | bge-m3, open weights, downloaded once and kept in house. You can run it yourself and check that the vectors we hand you really are its own. | A closed model: what it does, you know from what they state. |
| How much machine is behind it | 71 chunks of 1,500 characters per minute on 4 vCPUs, that is 106,500 characters a minute. The plan quotas below come from there, and the full arithmetic is in the documentation. | The capacity they promise you is in the limits of the plan you buy. |
Every figure in this table is checked by a benchmark that looks for it twice: here, and inside the measurement that produced it. If we re-measure something and this page lags behind, the benchmark goes red before a customer reads it.
Plans
A plan is a set of default values. The real numbers live on the licence and can be agreed when it is issued: the plan is there so nobody has to invent them every time. The names below are exactly the values the API accepts.
| Plan | For whom | Duration | Monthly quota | Per minute | Price |
|---|---|---|---|---|---|
| prova | anyone who wants to measure quality on their own corpus before deciding | 30 days | 5,000,000 characters | 10 requests | on request |
| standard | anyone putting a product into service | no expiry | 100,000,000 characters | 120 requests | on request |
| enterprise | large volumes, or a reserved instance | no expiry | agreed | 300 requests | on request |
The quotas are not round numbers picked by eye: they come out of the capacity we measured, and the whole calculation — throughput, monthly ceiling, what each plan weighs — is in the API documentation. Agile suite products have their own internal plan, included.
Prices are not on this page: they are quoted on request, together with the volume you have in mind.
Request a licence
Fill in the form: your request gets a number and we get back to you. No key is needed, no account is created and there is nothing to install. We keep only what you write here.
The form works with JavaScript turned off as well: it is a form, not an application. Rather write? agilev@agile.software.