quivr

Accepts diverse file types (PDF, DOCX, TXT, CSV, JSON, Markdown) and automatically chunks them into semantically meaningful segments using configurable chunk sizes and overlap strategies. The system parses each format with specialized loaders, then applies sliding-window or recursive chunking to prepare documents for embedding without losing context boundaries.

Converts chunked text into dense vector embeddings using pluggable embedding models (OpenAI, Hugging Face, local models) and stores them in a vector database (Supabase pgvector, Pinecone, or Weaviate). The system manages embedding batching, caching, and metadata association to enable semantic search without re-computing embeddings on every query.

Collects metrics on user interactions (queries, responses, document access) and system performance (retrieval latency, embedding quality, LLM token usage, cost). Provides dashboards or APIs to query usage patterns, identify popular documents, and monitor system health. Enables cost tracking per user/workspace and performance optimization based on real usage data.

Executes similarity search against stored embeddings to find relevant document chunks, then expands results with configurable context windows (preceding/following chunks) to provide LLMs with richer context. Uses cosine similarity or other distance metrics to rank results and optionally applies metadata filtering (date range, source, document type) before returning top-K results.

Maintains conversation history across multiple turns, using a sliding-window or summary-based memory strategy to keep context within LLM token limits. Each user message is processed through the retrieval pipeline to fetch relevant documents, then combined with conversation history and system prompts to generate coherent responses. The system tracks conversation state (user ID, session ID, turn count) to enable multi-user and multi-session support.

Abstracts LLM interactions behind a provider-agnostic interface supporting OpenAI, Anthropic, Hugging Face, and local models (via Ollama or similar). Handles API authentication, request formatting, response parsing, and error handling for each provider. Allows runtime model selection and parameter tuning (temperature, max_tokens, top_p) without code changes, enabling cost optimization and model experimentation.

Provides templating system for constructing prompts with dynamic placeholders for user queries, retrieved documents, conversation history, and system instructions. Templates support conditional logic (e.g., include history only if conversation length > N) and formatting options (e.g., numbered lists, markdown). At runtime, the system injects retrieved context, user input, and metadata into templates before sending to LLM.

Tracks the source and location (page number, chunk ID, document name) of each retrieved chunk and automatically generates citations in LLM responses. When the LLM references retrieved content, the system can append source metadata (e.g., '[Source: document.pdf, page 5]') or generate formatted citations (APA, MLA, Chicago style). Enables traceability of where information came from in the knowledge base.

Provides user authentication, workspace isolation, and role-based access control (RBAC) to support multi-tenant deployments. Each user has isolated document collections, conversation histories, and vector embeddings. The system manages user credentials, API keys, and workspace settings, enabling self-hosted or SaaS deployments where multiple organizations can use the same instance without data leakage.

Supports uploading multiple documents simultaneously and processes them asynchronously in the background, with progress tracking and error handling. Uses job queues (Celery, RQ, or similar) to distribute parsing, chunking, and embedding across workers, preventing blocking of the main application. Provides webhooks or polling endpoints to track ingestion status and retrieve results when complete.

Maintains version history for uploaded documents, allowing users to revert to previous versions or compare changes. When a document is updated, the system stores the new version alongside metadata (upload timestamp, uploader, change summary) and optionally re-embeds only changed chunks to avoid redundant computation. Enables rollback if a document is accidentally corrupted or outdated.