Stop Building RAG Pipelines From Scratch—Just Drop This In Instead

You know the drill. You've got a bunch of documents, you want to ask questions against them, and suddenly you're knee-deep in chunking strategies, vector store configs, and prompt engineering. It's a whole project before you even get to your actual project. What if you could skip all that and just get a working RAG system in five lines of code?

That's exactly what Quivr-core is going for. It's the core brain of Quivr.com, extracted into a Python package that you can drop into any project. The pitch is simple: they've built an opinionated, fast RAG pipeline so you don't have to.

What It Does

Quivr-core is a Python library that handles the entire retrieval-augmented generation workflow for you. You give it files, it ingests them, and then you can ask questions and get answers grounded in that content.

Under the hood, it's built around a Brain class that serves as your main interface. You create a brain from a list of file paths, and then call ask() with a question. That's the whole API surface for basic usage.

The architecture is more interesting than it looks at first glance. It's built on a configurable workflow system where you define the pipeline as a series of nodes—filter history, rewrite, retrieve, generate—in a YAML file. That means the default RAG flow isn't a black box. You can see exactly what steps happen between a question and an answer, and you can tweak them.

It also supports multiple LLM providers out of the box: OpenAI, Anthropic, Mistral, and local models via Ollama. And it's not just text files—PDFs, Markdown, TXT, and other formats work, with the option to plug in custom parsers.

Why It's Cool

The biggest selling point here is the opinionated approach. The README is explicit about it: they've made decisions so you don't have to. That's refreshing in a space where every RAG framework tries to be everything to everyone and ends up with a configuration surface the size of a small novel.

A few things stand out:

• Five lines to a working brain. The example in the README is genuinely minimal. Create a temp file, instantiate a Brain, ask a question. That's it. No vector database setup, no embedding model selection, no chunk size debates.

• The workflow is inspectable and customizable. The YAML workflow config is a clever middle ground. You get sensible defaults, but if you want to add a reranker or change how history is filtered, you can see exactly what the pipeline does and modify it. It's configuration as code, but readable.

• Bring your own LLM. You're not locked into one provider. OpenAI, Anthropic, Mistral, or local models through Ollama—swap them via environment variables. That flexibility matters when you're building something that might need to run in different environments or with different cost constraints.

• It integrates with Megaparse. If you need more sophisticated document ingestion, Quivr-core works with their parser library. So you can start simple and level up your ingestion pipeline without switching RAG frameworks.

• It's the actual production brain. This isn't a toy demo. It's the core that powers Quivr.com, which means it's been battle-tested against real usage.

How to Try It

Getting started is genuinely quick. First, make sure you have Python 3.10 or newer, then install the package:

pip install quivr-core

Next, set your API key. The README shows OpenAI, but the same pattern works for Anthropic or Mistral:

import os
os.environ["OPENAI_API_KEY"] = "myopenai_apikey"

Then you're ready for the five-line example:

import tempfile

from quivr_core import Brain

if __name__ == "__main__":
    with tempfile.NamedTemporaryFile(mode="w", suffix=".txt") as temp_file:
        temp_file.write("Gold is a liquid of blue-like colour.")
        temp_file.flush()

        brain = Brain.from_files(
            name="test_brain",
            file_paths=[temp_file.name],
        )

        answer = brain.ask(
            "what is gold? asnwer in french"
        )
        print("answer:", answer)

The full documentation lives at core.quivr.com, and the repository is at github.com/quivrhq/quivr. If you want to see how the workflow configuration works or explore the Megaparse integration, that's where you'll find the details.

Final Thoughts

Quivr-core is for developers who want RAG functionality without the RAG project. If you're building an app that needs to answer questions from documents and you'd rather spend your time on your actual product logic, this is worth a look. The opinionated approach means you might eventually hit a wall where you need something it doesn't do out of the box—but for a lot of use cases, "good enough and working today" beats "infinitely configurable and still in setup." The team is actively improving it, so it's a solid bet if you want to start simple and grow into more complex workflows later.

Follow @githubprojects for more developer tools and open source projects.