OpenRAG: Single-Command RAG Platform Built on Langflow, Docling, and OpenSearch

Building a production-grade RAG pipeline from scratch in 2026 still takes weeks. You need a document parser that handles messy real-world formats, a vector store that scales, an orchestration layer for retrieval workflows, and a frontend your team can actually use. Then you need to wire all of it together, debug why the chunking strategy loses important context, and figure out why retrieval quality drops at scale.

OpenRAG collapses that entire stack into one deployable package. It's an open-source RAG platform from IBM and the Langflow team that combines three best-in-class components — Langflow for agentic workflow orchestration, OpenSearch for production-grade semantic search, and Docling for intelligent document parsing — and ships them together with a web UI, REST API, Python and TypeScript SDKs, and a built-in MCP server. From zero to a functional document Q&A system in one command.

What OpenRAG is

OpenRAG is a comprehensive, single-package RAG platform that enables intelligent document search and AI-powered conversations. Users upload documents through a drag-and-drop interface, and the platform handles parsing, chunking, embedding, indexing, and retrieval automatically. The chat interface returns answers with source citations. Under the hood it's an agentic workflow powered by Langflow that you can inspect and customize.

The project lives at github.com/langflow-ai/openrag and openr.ag. It has approximately 1,000 GitHub stars with 95 forks and 51 releases, including the 0.3.0 milestone shipped in March 2026. Built by the Langflow team in collaboration with IBM's open source AI ecosystem.

The three components

Docling — document parsing

Docling is IBM Research's open source document parsing library that handles real-world document formats intelligently. PDF, Word, PowerPoint, HTML, images, scanned copies, Excel — Docling extracts structured content including tables, figures, and complex layouts that naive text extractors mangle. For RAG systems, document parsing quality is the first failure point: if the chunking strategy doesn't understand document structure, retrieval quality suffers from the start. Docling's layout-aware parsing is what makes OpenRAG handle enterprise document formats that other RAG systems struggle with.

OpenSearch — semantic search

OpenSearch (Apache 2.0, the AWS-maintained Elasticsearch fork) is the vector store and search backend. It provides hybrid search combining dense vector similarity with BM25 keyword matching. OpenSearch stores document chunks with their embeddings and handles both semantic similarity queries and exact keyword retrieval, with configurable weighting between the two signals.

Langflow — workflow orchestration

Langflow is the visual workflow builder that orchestrates the entire RAG pipeline. Every step — document ingestion, chunking strategy, embedding model selection, retrieval, re-ranking, LLM call, response generation — is a node in a visual graph you can inspect, modify, and debug. When retrieval fails you can see exactly where in the pipeline it failed, without instrumenting code yourself. Langflow also handles the agentic features — multi-agent coordination, re-ranking workflows, and intelligent nudges that steer the system toward better answers.

Features

• Pre-packaged and ready to run — all components are wired together out of the box
• Agentic RAG workflows — advanced orchestration with re-ranking and multi-agent coordination
• Document ingestion — drag-and-drop upload via web UI or programmatic upload via API
• Visual workflow builder — Langflow canvas for inspecting and customizing every pipeline step
• REST API — every operation available as an API endpoint
• Python and TypeScript SDKs — official SDKs for programmatic access
• Built-in MCP server — mounted at /mcp on your instance for IDE and AI tool integration
• Source citations — answers include traceable citations linking to source documents
• Kubernetes and Docker support — Helm charts, Docker Compose, GPU support included

SDK examples

from openrag import OpenRAGClient

client = OpenRAGClient()
response = client.chat.create(
    message="What does our security policy say about access control?"
)
print(response.response)
print(response.citations)

import { OpenRAGClient } from "openrag-sdk";

const client = new OpenRAGClient();
const response = await client.chat.create({
  message: "Summarize our Q1 engineering report"
});
console.log(response.response);

Getting started

git clone https://github.com/langflow-ai/openrag
cd openrag
docker compose up

Navigate to the web interface, upload your documents, and start asking questions. The entire stack — OpenSearch, Langflow, Docling, the FastAPI backend, and the Next.js frontend — comes up together. No separate configuration of each component, no wiring together endpoints manually.

The MCP server — queryable documentation from your IDE

Every OpenRAG instance includes an MCP (Model Context Protocol) server at /mcp. MCP is the protocol that lets AI tools like Cursor, Claude Desktop, and VS Code extensions call external tools as part of their reasoning loop.

In practice: upload your team's documentation to OpenRAG — architecture docs, runbooks, API specs, incident reports, onboarding guides — and query it directly from your IDE. Cursor can call your OpenRAG instance to retrieve relevant documentation while you're writing code. Claude Desktop can query your runbooks when you're debugging an incident. Any MCP-compatible tool accesses your knowledge base as a tool in its reasoning loop.

This is what distinguishes OpenRAG from a simple document Q&A tool. It's your entire documentation corpus becoming a queryable tool available to every AI assistant your team uses — automatically, from the IDE.

OpenRAG vs alternatives

vs Dify — Dify is a full LLM application platform with visual workflows, RAG, agents, and more. OpenRAG is narrower: specifically a RAG platform optimized for document search, built on three best-in-class components rather than a single vertically-integrated platform. Dify's broader scope means more features but more complexity. OpenRAG's focused scope means faster setup for document Q&A with agentic retrieval.

vs RAGFlow — RAGFlow (infiniflow) is a dedicated open source RAG engine with 46,000+ stars and strong enterprise focus: deep document understanding, complex format support, and a mature agent framework. RAGFlow is more mature and feature-complete. OpenRAG is newer, easier to set up, and has the MCP server and Langflow visual workflow builder as differentiators.

vs building on Langflow directly — OpenRAG is essentially a pre-configured, production-ready Langflow deployment with OpenSearch and Docling pre-wired. OpenRAG trades flexibility for speed — you can still customize the Langflow workflows, but the initial setup is handled.

vs Supabase + pgvector — Supabase with pgvector is excellent for applications needing vector search alongside relational data. OpenRAG is optimized specifically for document ingestion and retrieval at scale with OpenSearch providing better performance for large document corpora.

DevOps use cases

• Runbook Q&A — upload all your runbooks and query them via MCP from Cursor or Claude Desktop during incidents
• Architecture documentation search — upload ADRs and search them semantically
• Compliance and audit documentation — make compliance policies queryable for security questionnaires
• Onboarding knowledge base — new engineers query docs from their IDE without switching context
• Post-mortem search — upload incident reports and find similar past incidents when diagnosing a new one

Who it's for

Good fit:

• Engineering teams who want a complete RAG platform without building the stack themselves
• Teams who want documentation queryable from their IDE via MCP
• Organizations building internal knowledge bases on top of enterprise documents (PDF, Word, PowerPoint)
• Teams already using Langflow who want a pre-configured RAG deployment
• IBM ecosystem users who want Docling + OpenSearch in a ready-to-deploy package

Not the right fit:

• Teams that need a general-purpose LLM application builder — use Dify or Langflow standalone
• Teams that need mature enterprise RAG with proven scale — RAGFlow is more mature at 46k stars
• Simple single-document Q&A where a direct LLM call with context is enough

My take

OpenRAG solves a real problem: the gap between "I want to chat with my documents" and "I have a production RAG pipeline that actually works." Most teams that try to build RAG from scratch underestimate how much work the document parsing layer is, how much retrieval quality depends on chunking strategy, and how hard it is to debug why the system returns wrong answers. OpenRAG packages the right components for each job — Docling for parsing, OpenSearch for search, Langflow for orchestration — and pre-wires them together.

The MCP server is the feature I'd highlight to any engineering team. Having your documentation corpus queryable from Cursor or Claude Desktop changes how you interact with your own knowledge base. It's the difference between "I need to find that runbook" and "I'll ask about it while I'm debugging." That workflow improvement alone justifies the deployment overhead.

At ~1,000 GitHub stars, OpenRAG is young compared to RAGFlow or Dify. The IBM and Langflow team backing gives it credibility, but it hasn't yet accumulated the community validation that older projects have. Worth watching — and worth deploying if the use case fits.