Version 2.1 is here! Prompt management, admin UI search, Helm chart overhaul

Sovereign, Open Source Retrieval-Augmented Generation

Built by LINAGORA, OpenRAG is a modular framework for Retrieval-Augmented Generation (RAG). Production-ready and transparent by design, it empowers teams to develop state-of-the-art document-grounded AI systems, with full control of their stack. It is the RAG engine behind Twake.ai.

Deploy it yourself View the source
License
AGPL-3.0
Latest release
v2.1.1
Vector store
Milvus
Distributed with
Ray
API
OpenAI-compatible

Ask your documents

Grounded answers, with the sources attached.

Every answer cites the exact document and page it came from — and the citation is a link. Click one and the source opens, at that page.

openrag-OpenRAG Grounded only on the partition OpenRAG
Searching for relevant documents…
Type your message here…

Answer recorded verbatim from an OpenRAG deployment, on the OpenRAG partition. The three citations it returned are the links above.

How it works

RAG combines search and AI to deliver grounded answers.

Instead of relying only on the model's internal knowledge, RAG retrieves relevant documents and uses them to generate grounded, reliable answers with a large language model.

Documents PDF · video · e-mail Vector database indexed and kept up to date ? Question any language Vector query embedding Retrieval hybrid + rerank Augmentation top passages Prompt grounded LLM your model Generation streamed 1 2 Answer with citations

  1. DocumentsPDF · video · e-mail

  2. Vector databaseindexed and kept up to date

  3. Questionany language

  4. Vector queryembedding

  5. Retrievalhybrid + rerank

  6. Augmentationtop passages

  7. Promptgrounded

  8. LLMyour model

  9. Generationstreamed

  10. Answerwith citations

STEP 1

Query

The user submits a question or request.

STEP 2

Retrieval

The system searches the knowledge base for relevant documents.

STEP 3

Selection

Key chunks of context are chosen and ranked.

STEP 4

Generation

The language model combines the query with context to draft an answer.

STEP 5

Result

The output is grounded, traceable and explainable.

In five minutes

Understand everything about RAG.

openrag-OpenRAG Multimodal — video source
Searching for relevant documents…

5 min 15 s English subtitles Starts muted — unmute in the player

Type your message here…

Why OpenRAG

Four blocking points. Four answers.

Retrieval-Augmented Generation is becoming the standard way to access enterprise knowledge, but most existing tools hit critical limits.

The blocking point

Confidentiality gaps

Most RAG systems lack proper partitioning of data. Different users, teams, or departments often share the same index, creating risks of unauthorized access to sensitive information.

How OpenRAG answers it

Confidentiality first

OpenRAG supports secure partitioning of data per user or team, ensuring access control. Being fully open source and deployable on premises, it guarantees sovereignty and compliance.

The blocking point

Scale breaks the pipeline

Most RAG tools process documents one at a time. As a collection grows from thousands to hundreds of thousands, indexing stretches into days and results get noisier.

How OpenRAG answers it

Built to scale from the start

Parsing, chunking and indexing run in parallel across as many machines as you give it: add nodes, not workarounds. Hybrid search and reranking keep results sharp as the corpus grows.

The blocking point

Poor document handling

Documents of different types are treated the same way. Complex PDFs, scans, or audio files are poorly parsed, resulting in weak indexing and irrelevant answers.

How OpenRAG answers it

Smart, type-aware indexation

Dedicated pipelines handle PDFs, images, audio, and scans with layout-aware parsing and OCR, ensuring accurate indexing for every format.

The blocking point

No way to verify the answer

Most assistants produce fluent text with no trace of where it came from. In regulated environments, an answer you can't audit is an answer you can't use.

How OpenRAG answers it

Every answer traceable to its source

Answers cite the document and the page they came from, and each citation is a link that opens the source at that page. Reviewers check in one click instead of taking the model's word for it.

Key features

What makes it unique.

Open Source & Sovereign

AGPL-licensed, auditable, and community-driven.

LLM-Agnostic

Connect your own model (Mistral, Qwen, Lucie, Claude, GPT, and more) or use a hosted provider. You keep the freedom to choose the best model for your use case, without being locked into a single provider.

Vector Search with Milvus

Fast and precise semantic search on a vector database. Knowledge bases can be segmented per team or per user, ensuring relevant and secure information retrieval.

Multimodal Parsing

Audio transcription, image captioning, OCR and PDF layout awareness. From text and PDFs to audio and images, OpenRAG extracts and structures knowledge across formats.

Scalable with Ray

Process, embed, and rerank at cluster scale using Ray distributed tasks. Ingestion, chunking and embedding scale horizontally as your corpus grows — add machines, not workarounds.

Interfaces

A full admin console, a ready-to-use chat interface, and an OpenAI-compatible API for everything else.

The console

Run it like a platform, not a prototype.

Version 2 ships a React console covering partitions, documents, jobs, users, model endpoints, pipeline presets and, since 2.1, the prompt library — so the people who operate the stack rarely have to touch a configuration file.

Click any section to explore

https://openrag.demo/app/
OpenRAG Admin console
Chat Signed in Admin
Super Admin Mode enabled for this deployment. Admins can access all partitions and documents in this deployment.

Overview

Dashboard and quick actions

Partitions
77
Documents
3365
Users
48
Active Jobs
0

System status

API
Up
Version
2.1.1
Ray actors
7/7 alive

Quick Actions

Create PartitionSet up a new document partition Upload DocumentsAdd documents to a writable partition

Recent Jobs

View all
TaskFilePartitionState
c7c0ab36 annual-report-2026.pdf demo COMPLETED

The OpenRAG v2 console, reproduced from the running product. Sections, controls and configuration are real; the table rows are sample data.

Architecture

Built to survive production.

Version 2 rebuilt OpenRAG on a clean, layered architecture that keeps the core independent of the tools around it — so components can be swapped without rewriting the system.

Application layers — v2.0.0

core/ — domain + ports services/ — adapters api/ — transport di/ — composition

Entry points

FastAPI — /docs Chainlit chat — /chainlit Admin console — /app/ OpenAI-compatible API — /v1

Indexing pipeline — scheduled on Ray

Marker — layout analysis Docling PyMuPDF OCR / VLM Speech-to-text Enriched Markdown Chunking Embedding

Inference servers

LLM — vLLM VLM — vLLM Embedder — vLLM Reranker — Infinity

Storage

Milvus — vectors PostgreSQL — metadata, tasks, users

Retrieval that earns its answers

  • Hybrid search — semantic similarity combined with BM25 keyword matching.
  • Contextual retrieval — each chunk is enriched with a generated context sentence before embedding.
  • Smart query handling — vague questions are automatically reformulated to find better matches.
  • Multilingual reranking — a dedicated model re-ranks results so the most relevant passages come first, in any supported language.
  • Web search augmentation — optionally blend live web results alongside document sources, tagged separately in the response.

Scale without rewriting

  • Horizontal scaling — distribute processing across Ray worker nodes.
  • GPU acceleration — optimise inference across available hardware.
  • Resource management — intelligent allocation of compute across the cluster.
  • Monitoring — built-in metrics, with ready-made dashboards.
  • Kubernetes, OpenShift included — the Helm chart runs under OpenShift's restricted security policies without modification. Published at oci://ghcr.io/linagora/openrag-stack.

Built on

Ray Milvus vLLM Chainlit Hugging Face Docker Kubernetes

Works with

Open WebUI LangChain n8n

Security & governance

Isolation you can prove.

Switch to another partition and ask the same question. The model answers that it does not know — because the documents are genuinely unreachable from there.

  • Partition isolation — each partition behaves as its own knowledge base. Documents in one are unreachable from another.
  • Workspaces — named subsets of files inside a partition, so search can be scoped further without restructuring anything.
  • Role-based access — owner, editor and viewer roles per partition, enforced on every request, all the way down to the database query.
  • Hashed credentials — API tokens are stored only as a SHA-256 hash; the raw token is shown once at creation and never written to the database.
  • Token or single sign-on — bearer tokens for programmatic access, and any standards-compliant OpenID Connect provider for people: Keycloak, LemonLDAP::NG, Entra ID, Okta and others.

Secure by default

  • Scopes fail closed: an unresolved or empty scope returns nothing, never everything.
  • Internal fields are server-controlled and cannot be set by callers.
  • Outbound connections are verified, and secrets are redacted from logs and responses.
  • Containers run without root privileges, with rate limiting and security headers enabled by default.
  • Every release is audited, and fixes are published openly in the changelog.

Sovereignty & compliance

  • Your perimeter — OpenRAG runs on your own infrastructure. Documents, embeddings and queries stay where you put them, and no third party sees them.
  • Sovereign hosting — deployable onto your machines, or into hosting qualified SecNumCloud.
  • Beyond extraterritorial reach — run it yourself and there is no foreign operator for the Cloud Act, or any comparable law, to compel.
  • Evidence for GDPR and the AI Act — answers trace to their source passage, and the code is auditable end to end. The obligations fall on you as deployer; OpenRAG is built to let you meet them.

Integration

It already speaks your stack's language.

OpenRAG speaks the OpenAI API language, making it easy to embed into chatbots, workflows, and enterprise systems. Point an existing OpenAI-compatible client at OpenRAG and it works.

openrag_example.py 
from openai import AsyncOpenAI, OpenAI

base_url = 'https://demo-openrag.linagora.com/v1'  # api base url
openrag_auth_key = 'sk-####'

async_client = AsyncOpenAI(api_key=openrag_auth_key, base_url=base_url)
sync_client = OpenAI(api_key=openrag_auth_key, base_url=base_url)

# The partition is selected through the model id
data_partition = 'digital-sovereignty'
model_id = f'openrag-{data_partition}'

chat_completion = sync_client.chat.completions.create(
    model=model_id,
    messages=[
        {
          "role": "user",
          "content": "Can you tell me about digital sovereignty in Europe?"
        }
    ]
)
response_content = chat_completion.choices[0].message.content
print(response_content)

Partition through the model id

There is no custom adapter to write. The partition is selected with the openrag-<partition_name> convention, which is what makes partition isolation work through a completely standard OpenAI client.

Drops straight into

Open WebUI LangChain n8n Twake.ai

Supported formats

txtmd pdfdocx docpptx emlwav mp3mp4 oggflv wmaaac pngjpeg jpgsvg

All files are intelligently converted to Markdown, with images replaced by AI-generated captions.

Release notes

Version 2 is here!

A major release rebuilding OpenRAG on a clean, layered architecture, and a prompt library managed from the console rather than from template files on disk.

v2.0.0 Hexagonal architecture 8 July 2026
  • Hexagonal architecture — restructured into core, services, api and di layers, improving testability and easing long-term maintenance.
  • New admin UI — React console: partitions, documents, jobs, users, model endpoints, pipeline presets.
  • Pipeline presets — named indexation and retrieval configuration bundles, assignable per partition.
  • Security hardening — search filter-injection fix, SSRF guards, secret redaction, security headers, rate limiting, and non-root images.
v2.1.0 Prompt management 31 July 2026
  • Prompt management — prompts become a managed library in Postgres: create, edit and delete named prompts per type, mark one default per type, and assign them per partition.
  • Admin UI — full prompt CRUD, search in user management, and a partition-member picker replacing manual user-id entry.
  • Safer model endpoints — endpoint names with unsafe characters are rejected instead of silently becoming unreachable, and renaming one cascades to every stored reference.
  • Helm chart overhaul — per-component ingress, a global image registry, extra objects, and an admin-UI image that runs under a restricted OpenShift SCC.
Read the full changelog

Deploy

Up and running with one command.

shell
# 1. Clone with submodules
git clone --recurse-submodules \
  git@github.com:linagora/openrag.git
cd openrag

# 2. Configure
cp infra/compose/.env.example infra/compose/.env
cd infra/compose

# 3. Launch (GPU)
docker compose up -d

# or, CPU only
docker compose --profile cpu up -d

Prerequisites

Minimum specifications

  • Memory — 16 GB RAM minimum, 32 GB or more recommended
  • GPU — an NVIDIA GPU with at least 16 GB VRAM is recommended for best performance. A CPU-only profile is available for evaluation and smaller deployments.
  • Unified-memory machines work with 16 GB, though 32 GB is recommended

Then open

  • /app/ — the admin console, on port 8081 by default
  • /chainlit — the chat UI
  • /docs — the full FastAPI documentation

CONTAINERS

Published images

ghcr.io/linagora/openrag
ghcr.io/linagora/openrag-ray
ghcr.io/linagora/openrag-admin-ui

KUBERNETES

Helm chart

oci://ghcr.io/linagora/openrag-stack

Chart 0.6.2, app version 2.1.1. OpenShift deployment is documented too.

ROADMAP

Coming soon

Expanded format support (csv, odt, html), format-specific chunkers, tool calling, agentic RAG and MCP, plus encryption in transit and at rest.

Would rather not operate it yourself? LINAGORA runs OpenRAG as a managed service, on platforms subject neither to the Cloud Act nor to any other extraterritorial law.

A digital common

Built in the open, owned by everyone.

OpenRAG is a digital common. It is licensed under the AGPL-3.0, developed in public, and already run by public administrations and private companies alike — each on their own infrastructure, with their own models and their own data. The Conseil Départemental d’Ille-et-Vilaine searches its administrative corpus with it — deliberations, reports and agreements, queried in plain language.

Among them

Conseil Départemental d’Ille-et-Vilaine

The code is shaped by contributors from well beyond LINAGORA. Everyone is welcome: there is no contributor tier, no paid edition, and no feature held back.

Fork the repository Read the docs

What that commits to

  • Code that can be audited line by line, not a published binary.
  • Models you choose and hold yourself — nothing embedded that you cannot swap.
  • A documented pipeline, so you can explain how any answer was produced.
  • A community whose existence does not depend on one company surviving.

That last one carries the most weight. Software published under a free licence by a vendor that disappears stays legally free and becomes technically dead.

How to get involved

  • Fork this repository.
  • Create a new branch for your feature or fix.
  • Submit a pull request for review.

Feel free to ask questions, suggest features, or report bugs via the GitHub Issues page. Your feedback helps us improve!

TwakeThe engine inside Twake.ai

OpenRAG is the RAG engine that powers Twake.ai — the same code, in production, at scale.

The publisher

Good Tech For Good, made in France.

With its software and services, LINAGORA enables large public and private organisations to develop their technological independence.

SINCE

2000

An open source leader, in business for a quarter of a century.

PRESENCE

4 continents

Offices in France, Tunisia, Vietnam, Mauritius and Canada.

TEAM

200 employees

Building ethical, responsible and sustainable software.

OpenRAG is one of four

LINAGORA publishes four AI building blocks, each with its own job: Luciole for open language models — Apache-2.0 weights at 1, 8 and 23 billion parameters — LinTO for speech, Twake AI for collaboration, and OpenRAG for documents. Luciole works natively with OpenRAG for corpus querying, so the model and the retrieval layer come from the same place — and neither locks you into the other.

Respect for privacy 100% Open Source GAFAM-free guarantee Twake.ai LinShare LinTO Lucie & OpenLLM France

Let's build together

Want to integrate RAG in your business?

Whether you're building an AI assistant, a legal search engine, or multimodal enterprise Q&A, we can help you get there — fast, and with sovereignty.

Read the docs

Technical questions about the project? Open an issue on GitHub.

Contact us

Tell us about your project