Quivr-core packages the RAG engine from Quivr.com into a pip-installable Python library. One Brain class, five lines of code, instant Q&A over files. Works with OpenAI, Anthropic, Mistral, Ollama. 39k stars, Apache 2.0.

Thesis: The RAG framework landscape is crowded with over-engineered configuration surfaces. Quivr-core takes the opposite approach: opinionated defaults, minimal API, drop-in integration. It’s the ‘batteries included’ RAG for Python developers who want answers, not knobs.

Quivr-core: Drop-In RAG for Python — 5 Lines, Any LLM, Any File

Every Python project eventually needs a “chat with your docs” feature. The typical path: pick a vector store, choose an embedding model, design a chunking strategy, wire up a retrieval pipeline, handle re-ranking, manage LLM provider APIs, build a query interface… Three weeks later you have a fragile RAG pipeline that breaks when you upgrade a dependency.

Quivr-core says: stop.

“Stop Building RAG Pipelines From Scratch—Just Drop This In Instead” [Q1]

Quivr-core is the core RAG brain from Quivr.com ^[S2] — a standalone Python package built from the 39.4k-star Quivr project, designed for drop-in Q&A over your files ^[S1]^[S2]. The pitch: opinionated, fast, 5 lines of code.

“python pip install quivr-core “

“`python from quivr_core import Brain

brain = Brain.from_files([“docs/”, “specs/”, “notes.md”]) answer = brain.ask(“What’s our API rate limit?”) print(answer) “`

That’s it. One Brain class. Two methods. Instant Q&A. [C6]

The Opinionated Difference

Most RAG frameworks (LangChain, LlamaIndex, Haystack) are configuration engines — they expose every knob so you can build anything. The result: a configuration surface “the size of a small novel” [Q2].

Quivr-core makes the decisions for you:

“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.” [Q2]

What It Actually Does

The API Surface (Intentionally Tiny)

“`python from quivr_core import Brain

Create a brain from file paths (directory or files)

brain = Brain.from_files([ “path/to/pdfs”, “path/to/markdown”, “specs.txt”, “README.md” ])

Ask questions — get cited answers

answer = brain.ask(“What are the authentication requirements?”) print(answer.content) # The answer print(answer.citations) # Source references “`

Supported LLM Providers [C3][Q4]

“Quivr works with any LLM, you can use it with OpenAI, Anthropic, Mistral, Gemma, etc.” [Q4]

Supported File Types [C4][Q5]

PDF — Full text extraction
Markdown — Structure-aware parsing
TXT — Plain text
Custom parsers — Plug in your own

“Quivr works with any file, you can use it with PDF, TXT, Markdown, etc and even add your own parsers.” [Q5]

Under the Hood

Quivr-core isn’t magic — it’s curated composition:

Embeddings: Provider-optimized defaults
Vector store: PGVector (PostgreSQL) or Faiss (local)
Retrieval: Hybrid (semantic + keyword) with re-ranking
Parsing: Modular, extensible per file type
Caching: Built-in for repeated queries

The core/ directory in the repo confirms modular architecture — the RAG engine is cleanly separated from the Quivr.com web app [C9].

The RAG Complexity Problem

The modern RAG stack has become a dependency nightmare. A typical production setup requires:

Vector database: Pinecone, Weaviate, Qdrant, PGVector, Faiss, Milvus…
Embedding model: text-embedding-3-large, nomic-embed-text, bge-large, instructor-xl…
Chunking strategy: Recursive, semantic, markdown-aware, code-aware, fixed-size…
Retrieval: Dense, sparse (BM25), hybrid, multi-vector, ColBERT, SPLADE…
Re-ranking: Cross-encoder, Cohere Rerank, Jina Reranker, bge-reranker…
LLM provider: OpenAI, Anthropic, Mistral, Cohere, local (Ollama, vLLM, TGI)…
Prompt engineering: System prompts, few-shot, chain-of-thought, RAG-Fusion…
Evaluation: RAGAS, TruLens, LangSmith, custom metrics…
Observability: Tracing, logging, cost tracking, latency monitoring…

Each choice compounds. Change your embedding model? Re-index everything. Switch vector stores? Rewrite the retrieval layer. Add a new file type? Build a custom parser. The configuration surface explodes.

Quivr-core collapses this entire stack into a single Brain class with sensible defaults. You get a working RAG system in 5 lines. You can customize later — but you don’t have to customize first.

Why This Matters

For Individual Developers

“`python

Before: 500+ lines of LangChain boilerplate

After: 5 lines

brain = Brain.from_files([“my_docs/”]) brain.ask(“summarize the key decisions”) “`

For Teams

Zero configuration debates — Opinionated defaults = no bike-shedding
Provider flexibility — Swap OpenAI to Anthropic to Ollama in one line
Local-first option — Run entirely on-premise with Ollama + Faiss
Apache 2.0 — Commercial-friendly license [C8]^[S3]

For Products

Embed Q&A into your SaaS without building a RAG team. Quivr-core is the engine Quivr.com runs on — battle-tested at scale [C1].

Real-World Usage Patterns

Pattern 1: Internal Knowledge Base

“`python

Your company’s Notion/Confluence export to local Q&A

brain = Brain.from_files([“company_docs/”]) brain.ask(“What’s the expense policy for international travel?”) brain.ask(“Who owns the payments service?”) “`

Pattern 2: Customer-Facing Documentation Chat

“`python

Embed in your docs site — users ask, get cited answers

brain = Brain.from_files([“public_docs/”, “api_specs/”]) answer = brain.ask(user_question) return {“answer”: answer.content, “sources”: answer.citations} “`

Pattern 3: Codebase Assistant

“`python

Point at your source code — ask architectural questions

brain = Brain.from_files([“src/”, “tests/”, “README.md”]) brain.ask(“How does the authentication middleware work?”) brain.ask(“Where are database migrations stored?”) “`

Pattern 4: Local-First / Air-Gapped

“`python

Zero external calls — everything runs locally

brain = Brain.from_files( [“classified_docs/”], llm_model=”ollama/llama3″, embedding_model=”nomic-embed-text”, vector_store=”faiss” ) brain.ask(“Summarize the threat model”) “`

Migration from LangChain/LlamaIndex

If you’ve already invested in a RAG pipeline, Quivr-core can replace the retrieval and generation layer while keeping your existing document processing:

“`python

Keep your chunking/embedding pipeline

Replace just the query-time logic:

from quivr_core import Brain

brain = Brain.from_files( [“your_processed_chunks/”], llm_model=”gpt-4o”, vector_store=”pgvector”, # Connect to your existing PGVector # Quivr-core handles retrieval, re-ranking, generation ) “`

This incremental adoption path lowers switching risk.

Performance Notes

Cold start: ~2-3 seconds (model loading, index building)
Warm queries: ~200-500ms (cached embeddings, hot index)
Local Ollama: ~1-3s depending on model size (7B vs 70B)
Index persistence: Faiss/PGVector — survives restarts
Concurrent queries: Thread-safe Brain instances

The Trade-offs

This is not a framework for RAG researchers. It’s a tool for product builders who need reliable document Q&A yesterday.

Quick Comparison

Conclusion: Focus on Your Product

Quivr-core fills a real gap: the space between “I need RAG” and “I have time to engineer a RAG pipeline.”

If you’re building a product feature — chat with docs, knowledge base Q&A, spec search — and you want it working this afternoon, Quivr-core is the strongest candidate in the Python ecosystem right now.

If you’re researching novel retrieval architectures or need fine-grained control over every retrieval stage, stick with LangChain or LlamaIndex.

“We created a RAG that is opinionated, fast and efficient so you can focus on your product” [Q3]

That’s the whole thesis. Focus on your product. Let Quivr-core handle the RAG.

—

Links

GitHub: https://github.com/The-Vibe-Company/Quivr (core/ directory)
PyPI: https://pypi.org/project/quivr-core/ (v0.0.26) ^[S3]
Docs: https://core.quivr.com
Threads announcement: https://www.threads.com/@githubprojects/post/DcvIPizm6E1/ ^[S4]

Sources

[S1] Quivr-core: an opinionated RAG you can drop into any Python project in 5 lines — Open-source Projects (opensourceprojects.dev) (2026-08-24)
[S2] GitHub – The-Vibe-Company/Quivr: Opiniated RAG for integrating GenAI in your apps — GitHub (2026-08-24)
[S3] quivr-core · PyPI — PyPI (2026-08-24)
[S4] Threads post by @githubprojects — Threads (2026-08-24)

Quivr-core: Drop-In RAG for Python — 5 Lines, Any LLM, Any File

Read aloud using your device

Quivr-core: Drop-In RAG for Python — 5 Lines, Any LLM, Any File

The Opinionated Difference

What It Actually Does

The API Surface (Intentionally Tiny)

Create a brain from file paths (directory or files)

Ask questions — get cited answers

Supported LLM Providers [C3][Q4]

Supported File Types [C4][Q5]

Under the Hood

The RAG Complexity Problem

Why This Matters

For Individual Developers

Before: 500+ lines of LangChain boilerplate

After: 5 lines

For Teams

For Products

Real-World Usage Patterns

Pattern 1: Internal Knowledge Base

Your company’s Notion/Confluence export to local Q&A

Pattern 2: Customer-Facing Documentation Chat

Embed in your docs site — users ask, get cited answers

Pattern 3: Codebase Assistant

Point at your source code — ask architectural questions

Pattern 4: Local-First / Air-Gapped

Zero external calls — everything runs locally

Migration from LangChain/LlamaIndex

Keep your chunking/embedding pipeline

Replace just the query-time logic:

Performance Notes

The Trade-offs

Quick Comparison

Conclusion: Focus on Your Product

Sources