Augmented retrievalfor your agents.
Pick where you come in. RAGfly is the same ground for all three.
Consume it from wherever you work — MCP, REST, CLI or SDK. The document context layer comes solved; you build the agent logic.
I'm building an agent for one client
You have a large corpus and don't want to own the RAG infrastructure. Point RAGfly at the directory and build the agent logic, not the pipeline.
Start freeAgents for many clientsI deploy agents for many clients
You serve many and need each one's corpus kept isolated. Multi-tenant out of the box, governed from a single panel.
See multi-tenantRAG in my SaaSI'm adding RAG to my SaaS
You don't want to rebuild ingestion, scale, multi-tenancy and security. RAGfly gives it to you solved, consumed via MCP, REST, CLI or SDK.
See the surfacesThe RAG that works with 1,000 documents breaks at 100,000.
Almost all software will carry AI agents, and almost all of those agents need to talk to private documents: contracts, case files, regulations, records, manuals. That's where everyone hits the same wall: solving ingestion, vectorization, freshness, isolation between clients and auditing at scale becomes an infrastructure project in itself — expensive, slow and easy to get wrong.
- Assemble vector DB + parser + framework + your own security layer
- Build multi-client isolation by hand (and pray it doesn't leak)
- Upload the documents to a third-party cloud
- Lock yourself into a vector DB or LLM vendor
- Months of integration before the first result
- Point at a directory; ingestion, vectorization and indexing are automatic
- Multi-tenant out of the box: an isolated corpus per client, from the database up
- Cloud does not retain the original; Desktop processes it locally; on sovereign plans the database belongs to the customer
- DB-agnostic and BYO: bring your own vector database and your own model
- From zero to an agent answering with citations in under 30 minutes
The document context layer for agents.
Point RAGfly at a directory of documents — thousands or tens of thousands, scanned ones included — and get a secure, multi-tenant, production-ready retrieval foundation. Retrieval at scale, isolation between clients and data governance come solved. You focus on your agent's logic; RAGfly is the ground it stands on.
- Pointing is your whole job — governing many clients doesn't cost you an engineering project
- Text, tables, layout and scans: PDF, Word, Excel, plain text
- Production-ready from the very first directory
- ✓Contratos 2025128 archivos
- ✓Auditorías Q447 archivos
- ✓Procedimientos RRHH312 archivos
- ✓Minutas Directorio89 archivos
Three things together, in order of edge.
Multi-tenant out of the box
An isolated corpus per client, governed from a single panel with a Groups → Entities → Areas structure. Serve 20 clients from one platform without a single piece of data crossing from one to another. It's what cloud-first context engines don't solve: there, you build that isolation yourself.
Precise privacy for each deployment mode
RAGfly processes both ingestion and retrieval. Cloud processes the original file but does not retain it after ingestion. Desktop processes the original and extraction inside your network and may synchronize encrypted derivatives. On sovereign plans, the customer owns the database and derivatives at rest, while RAGfly accesses chunks to retrieve context.
From directory to production
No integration project. Ingestion, vectorization and indexing are automatic, at the scale of tens of thousands of files. Your only job is to point; the system handles the rest.
And the layer underneath — where the value lives
Retrieval intelligence, not just storage: reranking, hybrid search, adaptive chunking, freshness, permission filtering and citation accuracy. It's what the agent can't do on its own — it can't see inside the corpus. And an action layer, not just a context layer: the agent invokes operations over sets of documents by prompt, not just retrieving chunks.
| Building it yourself | With RAGfly |
|---|---|
| Assemble vector DB + parser + framework + your own security layer | Point at a directory; ingestion, vectorization and indexing are automatic |
| Build multi-client isolation by hand | Multi-tenant out of the box: an isolated corpus per client, from the database up |
| Upload the documents to a third-party cloud | Cloud does not retain the original; Desktop processes it locally; on sovereign plans the database belongs to the customer |
| Lock yourself into a vector DB or LLM vendor | DB-agnostic and BYO: bring your own vector database and your own model |
| Months of integration before the first result | From zero to an agent answering with citations in under 30 minutes |
A single conversational entry point. No clunky menus.
RAGfly has a chat that isn't for "chatting with your files" — it's for operating the platform by talking to it. Add a user, create a profile, change someone's area or request support, all from the same place. Need a token? Ask how and it takes you to the form. Change a user's area? It does it, or opens the screen for you.
And yes, you can also query your documents and test retrieval before integrating anything. It's the fastest way to see the value in ten minutes — before writing a line of code.
A DX test, not the product: the chat uses every primitive, but the focus is on the infrastructure.
You don't give your agent access to the documents. You give it a profile.
In RAGfly, everyone who queries is an identity with permissions. An identity can be a person (signs in with their email) or a profile: a reusable service identity, with a blind code and no personal data behind it.
The agent comes in as "Finance Analyst" and sees exactly what that profile would see — its area, its level, its entity — with the same rules an employee would have. The RBAC that protects people protects agents just the same: the finance agent doesn't touch HR or another company in the holding.
You define the profile once and assign it to any agent, today or next year. For a consultancy deploying agents for 20 clients, that's 20 isolated sets of profiles, governed from a single place. It's the answer to the number-one fear of anyone putting an agent into a regulated organization: that it leaks a document it shouldn't have seen.
The same platform, two modes.
Same interface. In Cloud, RAGfly processes the original and relevant chunks. On Desktop, the local component processes the original inside your network and keeps it out of RAGfly Cloud.
Start in minutes, with no infrastructure of your own. RAGfly provisions everything and you point at your directory.
- Zero startup friction
- "In-flight" vectorization, encrypted data
- Managed scale without operating anything
The original and its extraction are processed inside your network. Derivatives may be synchronized, and RAGfly processes chunks during retrieval.
- The original file does not reach RAGfly Cloud
- Orchestrates real directories per user
- Hands your agent each file's local path, not a copy — it opens the file where it lives
Desktop doesn't replace your agent — Claude Code, whichever you use: it serves it better. It's the same RAGfly action layer, more powerful when it runs inside your network.
MCP, REST, CLI or SDK. Use it from wherever you work.
Four surfaces, on every plan. The message is one of neutrality; the path we show first is MCP.
MCP
abrimos aquíConnect RAGfly as an MCP server and your agent converses with the documents without you building any UI. It's where we open the door.
REST
The universal production foundation. The base everything else sits on.
CLI
DX, operations and bulk ingestion. Day-to-day convenience.
SDK
Integrate RAGfly directly into your code. Python and TypeScript. No MCP infrastructure required.
{
"mcpServers": {
"ragfly": {
"url": "https://api.ragfly.ai/mcp/sse",
"headers": { "Authorization": "Bearer slm_live_xxxxxxxxxx" }
}
}
}For technical folks, the foundations.
Stack and BYO
01Postgres + pgvector (Supabase to get started) + embeddings. A dedicated vector DB stays as a scale option, and you can always bring your own (BYO vector database + BYO LLM).
SQL-native metadata
02Each document's state lives in a relational database on Postgres: mixed SQL + vector queries inside your network, without a closed API in a third party's cloud.
First-class parsing / OCR
03Text, tables, layout and messy scans (PDF, Word, Excel, plain text). Deliberate scope on text + OCR, no audio or video.
Parameter hierarchy
04Four levels — System, Group, Entity, User — where the lowest overrides the one above. The logic is configured with prompts that the engine compiles into behavior.
Your data is yours. Always.
Protection is a design pillar, not a premium plan. Confidential documents stay under your organization's control.
- 01Cloud processes the original file but does not retain it after ingestion; chunks, embeddings and metadata persist
- 02Document data encrypted at rest in the database
- 03Structural filtering from the database up: every access goes through views that filter what each identity can see
- 04Full isolation between organizations: no group sees another's data
- 05Granular RBAC by area, role and profile — the same for people and agents
- 06Internal operation only through validated APIs: no surface for prompt injection
- 07Two-factor authentication and secure JWT tokens
- 08Full audit trail: every action logged with identity, date and module
- 09Encrypted communications (HTTPS) across every layer
- 10Desktop processes the original locally; on sovereign plans the customer owns the database and derivatives at rest, while RAGfly accesses chunks to retrieve context
Clear plans for Pages, Retrievals and Verified Answers.
Free
POC and evaluation
- 500 total Pages
- 1 Entity
- 25 Retrievals/day
- 50 total Verified Answers
- Playground included
- *
Starter
To start in production
- 2,000 Pages/mo
- 2 Entities
- 5,000 Retrievals/mo
- 300 Verified Answers/mo
- Additional pack: +250 Verified Answers for $25
- RAGfly Desktop
- Agentic Retrieval add-on
- **
Growth
For teams with Area Control
- Everything in Starter
- 10,000 Pages/mo
- 5 Entities
- 25,000 Retrievals/mo
- 1,500 Verified Answers/mo
- Additional pack: +1,500 Verified Answers for $120
- Area Control and BYOK
- Agentic Retrieval add-on
- ***
Scale
For production at scale
- Everything in Growth
- 40,000 Pages/mo
- 15 Entities
- 100,000 Retrievals/mo
- 5,000 Verified Answers/mo
- Additional pack: +10,000 Verified Answers for $700
- BYO vector database + BYO LLM
- Agentic Retrieval add-on
- ****
Enterprise / Sovereign
Annual contract and dedicated deployment
- Everything in Scale
- Custom Pages
- Custom Entities
- Custom Retrievals
- Custom Verified Answers
- BYOK + BYO vector/LLM
- DPA/SLA
- Dedicated deployment when applicable
- *****
* Free is a POC with total limits, not a production plan.
** Overage is billed only when usage exceeds the plan allowance.
*** Area Control/BYOK requires initial group configuration.
**** BYO requires technical review of the selected vector database and LLM.
***** Enterprise/Sovereign is sales-assisted: annual contract, DPA/SLA and dedicated deployment when applicable.
Augmented retrieval for your agents.
RAG infrastructure, solved
Ingestion, scale, multi-tenancy and security come solved. You build the agent logic, not the infrastructure.
Multi-tenant for those who serve many
Isolated clients from a single panel — what cloud-first vendors don't offer.
Explicit privacy by deployment mode
Cloud does not retain the original; Desktop processes it locally; on sovereign plans the customer owns the database. RAGfly processes chunks to retrieve context.
No lock-in
DB-agnostic, compatible with Claude, GPT, Gemini and open-source models. Bring your DB and your model.
From directory to production in minutes
No integration project, no developers needed to get going.
The infrastructure nobody wants to rebuild
It's to document context infrastructure what Stripe is to payments.
Building agents that need to talk to private documents?
Start free and connect your first directory via MCP in minutes.
Not ready to sign up? Join the early-access list and we'll let you know.
Prefer to write to us directly? info@ragfly.ai