quivr

Ingests diverse document types (PDF, TXT, Markdown, DOCX) through Brain.from_files() and automatically chunks content into semantically meaningful segments for vector storage. Uses configurable chunking strategies that preserve document structure while optimizing for retrieval performance. Handles file parsing, text extraction, and pre-processing in a unified pipeline before embedding.

Abstracts vector storage through a configurable backend system supporting PGVector (PostgreSQL), FAISS (local), and other vector databases. Automatically generates embeddings using configured LLM endpoints and persists vectors with metadata. The Brain class manages the lifecycle of vector store initialization, document indexing, and retrieval without exposing backend-specific APIs to the user.

Provides the Brain class as a stateful container for RAG operations, managing document ingestion, vector store lifecycle, conversation history, and pipeline configuration. Brain instances can be serialized and persisted to disk or external storage, enabling recovery of RAG state across application restarts. Supports both in-memory and persistent backends.

Provides configurable prompt templates for each RAG pipeline step (query rewriting, retrieval, generation) that can be customized via configuration files or programmatically. Templates support variable substitution for query, context, and conversation history. Enables fine-tuning of LLM behavior without code changes.

Provides a production-ready FastAPI backend that exposes Quivr RAG capabilities through REST endpoints. Handles authentication, request validation, error handling, and response formatting. Integrates with Supabase for user management and document storage. Enables deployment of RAG as a scalable web service.

Provides a production-ready Next.js frontend application with a chat interface for interacting with RAG. Includes real-time message streaming, conversation history display, document upload, and configuration management. Integrates with the FastAPI backend and provides a reference implementation for RAG UI patterns.

Implements a sophisticated RAG workflow using LangGraph that chains together four key steps: filter_history (conversation context management), rewrite (query optimization), retrieve (semantic search), and generate_rag (LLM-based answer generation). Each step is a discrete node in a directed acyclic graph, enabling conditional routing, error handling, and extensibility. The QuivrQARAGLangGraph class manages state transitions and data flow between steps.

Automatically rewrites user queries using an LLM before retrieval to improve semantic matching and reduce ambiguity. The rewrite step in the RAG pipeline transforms natural language queries into optimized forms that better align with document content and retrieval model expectations. This step operates within the LangGraph pipeline and uses the configured LLM endpoint.

Performs semantic similarity search against the vector store to retrieve relevant document chunks, with optional filtering based on conversation history to avoid redundant or contradictory context. The retrieve step uses the rewritten query to find top-k similar chunks, and the filter_history step prunes conversation history to fit within token budgets while preserving semantic continuity. Both steps operate within the LangGraph pipeline.

Abstracts LLM provider integrations through the LLMEndpoint class, supporting OpenAI, Anthropic Claude, Mistral, and local models via Ollama. Provides a unified interface for model inference, streaming, and function calling across providers with automatic fallback and error handling. Configuration-driven provider selection allows switching models without code changes.

Provides ask_streaming() method that returns tokens incrementally as the LLM generates them, enabling real-time response display in user interfaces. Implements streaming across the entire RAG pipeline, from query rewriting through final answer generation. Handles provider-specific streaming protocols (Server-Sent Events for OpenAI, etc.) and normalizes them into a unified token stream.

Enables RAG pipeline customization through YAML configuration files that define workflow steps, LLM endpoints, vector stores, and tool integrations without code changes. The configuration system parses YAML specs and instantiates the corresponding Brain and RAG pipeline components. Supports conditional routing, tool definitions, and prompt templates within the configuration layer.

Provides a framework for integrating external tools (web search, APIs, custom functions) into the RAG pipeline through a tool registry and function calling interface. Tools are defined declaratively with schemas and can be invoked by the LLM during generation or as separate pipeline steps. Includes built-in web search tools and supports custom tool definitions.

Manages multi-turn conversation state through the filter_history pipeline step, which maintains conversation history while respecting token budgets and semantic coherence. Implements heuristic-based history pruning that removes older messages while preserving recent context and key information. Conversation state is tracked in the Brain object and passed through the RAG pipeline.