Vault FAQ

Vault is a self-hosted knowledge base that uses AI to help you find information in your documents. It's like a super-powered search engine for your company's internal knowledge.

Here's how it works:

1. You upload documents: PDFs, Word files, web pages, spreadsheets, etc.
2. Vault processes them: Breaks them into chunks, creates AI embeddings (numerical representations of meaning)
3. You ask questions: "What's our refund policy?" or "Show me precedents for non-compete clauses"
4. Vault finds answers: Retrieves relevant document sections and uses AI to generate a concise answer

The key difference from regular search: Vault understands meaning, not just keywords. It can find relevant information even if the exact words aren't in your query.

Businesses have a knowledge problem:

• Information is scattered: Documents, wikis, emails, Slack messages, databases — knowledge is everywhere
• Search is broken: Keyword search misses context. Searching "refund policy" won't find "customer returns" even if they're the same thing
• AI tools require sending data to the cloud: Cloud AI services (ChatGPT, Glean, etc.) require sending your documents to their servers — a dealbreaker for regulated industries

Vault solves this by providing self-hosted AI-powered knowledge retrieval. Your documents stay on your infrastructure. No data leaves your servers. Full sovereignty.

Vault is designed for regulated and data-residency-sensitive organizations:

• Healthcare: HIPAA-compliant knowledge retrieval for patient records, clinical guidelines, policies
• Legal: Privileged document search for case files, precedents, contracts — without sending data to cloud AI
• Financial services: Regulatory document search, compliance knowledge base, audit trails
• Government: Classified document retrieval with full data sovereignty
• EU-based enterprises: GDPR-compliant knowledge management with data residency controls

If you have sensitive documents and can't send them to cloud AI services, Vault is for you.

RAG = Retrieval-Augmented Generation. It's the technology behind Vault.

Here's how it works:

1. Retrieval: When you ask a question, Vault first retrieves relevant document sections (using AI embeddings and vector search)
2. Augmented: Those document sections are augmented (added) to the AI's context
3. Generation: The AI then generates an answer based on the retrieved context

Why this matters:

• Accuracy: The AI answers based on your actual documents, not hallucinated from training data
• Traceability: You can see which documents the answer came from
• Up-to-date: The AI uses your latest documents, not stale training data

Key differences:

ChatGPT is a general-purpose AI assistant. Vault is a knowledge retrieval system specifically designed for your internal documents. Use ChatGPT for general questions; use Vault for company-specific knowledge.

Glean and Onyx are excellent cloud RAG platforms, but they have different design priorities:

Choose Glean/Onyx if you don't have sovereignty requirements and want a managed service. Choose Vault if you need full data control or want to self-host.

Yes. Vault's core is open source (Apache 2.0 license). You can:

• Self-host for free: Download, deploy, and use Vault without paying anything
• Modify the code: Customize Vault to your needs
• Contribute: Submit pull requests, report bugs, join the community

The enterprise layer (SSO, advanced RBAC, audit logging, compliance features, premium support) is paid. This is how we fund development.

"Sovereign" means full control over your data:

• Data location: Your documents stay on your infrastructure (on-premises or private cloud)
• Processing: All AI processing (embeddings, retrieval, generation) happens on your infrastructure
• No external dependencies: No data sent to OpenAI, Anthropic, or any third party (unless you choose to use their APIs)
• Auditability: You can inspect the code, logs, and data flows

This is critical for regulated industries. You can't claim data sovereignty if your AI tool is sending your documents to a cloud vendor.

For deployment: Yes. Vault is self-hosted, so you need someone who can manage Docker/Kubernetes, configure networking, and monitor infrastructure. This is typically a DevOps engineer or IT consultant.

For day-to-day use: No. The admin console is designed for non-technical users (knowledge managers, compliance officers). You can upload documents, create knowledge bases, and query the system without writing code.

For developers: Vault provides a REST API and SDKs (Python, JavaScript) for custom integrations. Developers can build custom workflows, integrate Vault into internal tools, etc.

Vault supports a wide range of document formats:

• PDF: Text-based PDFs (scanned PDFs require OCR — see below)
• DOCX: Microsoft Word documents
• HTML: Web pages
• Markdown: .md files
• Plain text: .txt files
• CSV: Comma-separated values (structured data)
• JSON: Structured data

Additional formats (PPTX, XLSX, email formats) are planned for future releases.

Vault processes documents in three steps:

1. Chunking: Documents are broken into smaller chunks (typically 500-1,000 words each). This makes retrieval more precise — instead of returning an entire 50-page document, Vault returns the specific paragraphs that answer your question.
2. Embedding: Each chunk is converted into a numerical representation (embedding) using an AI model. Embeddings capture the meaning of the text — similar meanings have similar embeddings.
3. Storage: Embeddings are stored in a vector database. When you query Vault, your question is also converted into an embedding, and Vault finds the most similar document chunks.

This entire process happens automatically when you upload documents. No manual configuration required.

Chunking is the process of breaking documents into smaller pieces. It matters because:

• Precision: Instead of returning an entire 50-page document, Vault returns the specific paragraphs that answer your question
• Context window: AI models have limited context windows (how much text they can process at once). Chunking ensures each piece fits within the context window
• Efficiency: Smaller chunks are faster to retrieve and process

Vault offers three chunking strategies:

• Fixed-size: Chunks are a fixed number of words (e.g., 500 words). Simple, predictable.
• Semantic: Chunks are based on meaning — sentences with similar meaning are grouped together. More accurate, but slower.
• Structural: Chunks are based on document structure (headings, paragraphs, sections). Best for well-structured documents.

Embeddings are numerical representations of text. They capture the meaning of text in a way that AI can understand.

Here's how they work:

• Each piece of text (a sentence, paragraph, or chunk) is converted into a list of numbers (e.g., [0.12, -0.34, 0.56, ...])
• Text with similar meanings has similar embeddings (numbers are close together)
• Text with different meanings has different embeddings (numbers are far apart)

Example:

• "How do I request a refund?" and "What's the return policy?" have similar embeddings (same meaning)
• "How do I request a refund?" and "What's the weather today?" have different embeddings (different meanings)

Vault uses embeddings to find relevant document chunks when you ask a question. Your question is converted into an embedding, and Vault finds document chunks with similar embeddings.

Yes. Vault supports bulk upload:

• Web UI: Drag and drop multiple files or folders
• API: Upload files programmatically via REST API
• Connectors: Sync documents from external sources (file system, S3, WebDAV, SharePoint)

For large document collections (1,000+ files), we recommend using connectors or the API. The web UI is best for smaller uploads (10-100 files).

Yes. Vault includes a connector framework for external data sources:

• File system: Sync documents from local or network drives
• S3-compatible: Sync from AWS S3, MinIO, or other S3-compatible storage
• WebDAV: Sync from WebDAV servers (e.g., Nextcloud, ownCloud)
• SharePoint: Sync from Microsoft SharePoint (Enterprise tier)
• Google Drive: Sync from Google Drive (Enterprise tier)
• Custom: Build your own connector using the connector SDK

Connectors can sync on a schedule (e.g., every hour) or in real-time (via webhooks).

Yes. Vault supports incremental updates:

• File change detection: Vault detects when a file is modified (via file system monitoring or connector sync)
• Re-processing: Vault re-processes only the changed document (not the entire knowledge base)
• Versioning: Vault keeps track of document versions — you can see which version of a document was used to answer a query

This ensures your knowledge base is always up-to-date without re-processing everything from scratch.

Yes. Vault supports multiple knowledge bases:

• Separation: Create separate knowledge bases for different teams, projects, or document types (e.g., "HR Policies", "Engineering Docs", "Legal Contracts")
• Isolation: Each knowledge base has its own documents, embeddings, and access controls
• Query scope: Query a specific knowledge base or search across all knowledge bases
• Permissions: Control who can access which knowledge bases (Enterprise tier)

This is useful for multi-tenant deployments (e.g., MSPs managing multiple customers) or organizations with strict data separation requirements.

Vault competes on sovereignty + model flexibility. If you need full data control and want to choose your AI models, Vault is the best option.

PrivateGPT and Quivr are open-source RAG tools, but they have different design priorities:

PrivateGPT/Quivr are great for experimentation, but not production-ready for enterprise use. Vault is designed for regulated businesses that need reliability, security, and support.

Model-agnostic means Vault works with any AI model — you're not locked into a specific vendor.

Vault supports:

• Local models: Run models on your own hardware via Ollama, vLLM, or llama.cpp (full sovereignty)
• API-based models: Use OpenAI, Anthropic, Google, or custom endpoints (when you need frontier capabilities)
• Embedding models: Choose any embedding model (OpenAI, Cohere, sentence-transformers, etc.)

You can even switch models per query — use a local model for simple questions (fast, sovereign) and an API model for complex questions (more capable).

Yes. Vault supports fully offline deployment:

• Local models: Run embedding and generation models on your own hardware (via Ollama, vLLM, llama.cpp)
• No external dependencies: Vault doesn't require internet access for inference, embeddings, or any core functionality
• Air-gapped: Deploy in air-gapped environments (no internet access at all)

This is critical for government, military, and high-security environments where internet access is restricted or prohibited.

Vault's retrieval accuracy depends on several factors:

• Embedding model: Better embedding models = better retrieval. We recommend state-of-the-art models (e.g., OpenAI text-embedding-3-large, Cohere embed-v3)
• Chunking strategy: Semantic chunking is more accurate than fixed-size chunking (but slower)
• Document quality: Well-structured, clear documents = better retrieval
• Query clarity: Clear, specific questions = better retrieval

Target: ≥85% MRR@10 (Mean Reciprocal Rank at 10) on benchmark corpus. This means the correct answer is in the top 10 results 85% of the time.

Yes. Vault provides configurable retrieval strategies:

• Similarity search: Find the most similar document chunks (default)
• Hybrid search: Combine similarity search with keyword search (BM25). Better for queries with specific terms.
• Re-ranking: Use a cross-encoder model to re-rank results after initial retrieval. More accurate, but slower.
• Metadata filtering: Filter results by metadata (e.g., only return documents from a specific department, date range, etc.)

For developers: Vault's retrieval pipeline is modular — you can write custom retrieval logic using the SDK.

Yes. Vault supports multi-language documents:

• Document ingestion: Upload documents in any language (English, Chinese, Spanish, French, etc.)
• Embedding models: Use multi-language embedding models (e.g., multilingual-e5, OpenAI text-embedding-3-large)
• Query: Ask questions in any language — Vault retrieves relevant documents regardless of language

The UI is currently English-only (v1), but multi-language UI is planned for v1.1.

Yes. Vault's core is open source (Apache 2.0 license):

• Transparent: All code is publicly available on GitHub
• Auditable: You (or your security team) can inspect the code for vulnerabilities, backdoors, or data exfiltration
• Verifiable: You can verify that Vault does what it claims — no hidden telemetry, no data sent to third parties

This is critical for sovereignty-focused organizations. You should be able to verify what your AI tools are doing.

Vault provides multiple ways to query:

• Web UI: Type questions in the search bar (like Google)
• API: Send queries via REST API (for custom integrations)
• SDK: Use Python or JavaScript SDKs (for developers)

Example queries:

• "What's our refund policy?"
• "Show me precedents for non-compete clauses"
• "Summarize the Q3 financial report"
• "What are the HIPAA requirements for data encryption?"

Vault retrieves relevant document chunks and uses AI to generate a concise answer. You can also view the source documents for verification.

Yes. Vault provides source citations:

• Answer: AI-generated answer based on retrieved documents
• Sources: List of document chunks used to generate the answer (with document name, page number, and relevant text)
• Confidence score: How confident Vault is in the answer (based on retrieval similarity)

This allows you to verify the answer and trace it back to the original documents — critical for regulated industries where accuracy and auditability matter.

If Vault can't find relevant documents, it will say "I don't know" instead of making something up.

This is a key feature of RAG — the AI is grounded in your documents. If the information isn't in your knowledge base, Vault won't hallucinate an answer.

You can also configure Vault to:

• Return partial answers: "I found some related information, but I'm not sure if it fully answers your question"
• Suggest related queries: "I couldn't find an answer, but you might want to try searching for X"
• Flag for review: "This question couldn't be answered — consider adding relevant documents to the knowledge base"

Yes. Vault supports conversational queries:

• Context retention: Vault remembers the context of your previous questions in the same session
• Follow-up: Ask "Can you elaborate on that?" or "What about the exceptions?" and Vault understands the context
• Session management: Each conversation is a separate session — context doesn't bleed between sessions

This makes Vault feel like a conversation with a knowledgeable colleague, not just a search engine.

Yes. Vault supports metadata filtering:

• Document metadata: Filter by document attributes (e.g., department, author, date, document type)
• Custom metadata: Add custom metadata to documents (e.g., tags, categories, classification level)
• Query-time filtering: "Show me HR policies from 2025" or "Find legal contracts classified as 'confidential'"

This is useful for large knowledge bases where you want to narrow the search scope.

Query speed depends on your setup:

For latency-sensitive applications, we recommend:

• Using fast embedding models (e.g., sentence-transformers/all-MiniLM-L6-v2)
• Using fast generation models (e.g., Llama 3 8B for local, GPT-4o-mini for API)
• Enabling caching (frequently asked questions are cached)

Yes. Vault supports query result export:

• Web UI: Download results as PDF, Markdown, or plain text
• API: Retrieve results in JSON format (for programmatic use)
• Batch export: Export multiple query results at once (for reporting or analysis)

This is useful for generating reports, sharing answers with colleagues, or archiving query results for compliance purposes.

Yes. Vault provides query analytics (Enterprise tier):

• Query history: See all queries asked by all users (with timestamps, users, and results)
• Usage patterns: Identify frequently asked questions, popular knowledge bases, and common topics
• Cost attribution: Track API costs per user, team, or knowledge base (if using API-based models)
• Unanswered queries: Identify questions Vault couldn't answer — these are gaps in your knowledge base

This helps you understand how Vault is being used and where to improve your knowledge base.

Yes. Vault is built with security best practices:

• Self-hosted: Runs on your infrastructure — no data leaves your servers
• Encryption: AES-256 at rest, TLS 1.3 in transit
• Access control: RBAC, document-level permissions, SSO (Enterprise tier)
• Audit logging: Tamper-evident logs of all access and queries (Enterprise tier)
• Open source: Code is auditable — you can verify there are no backdoors or data exfiltration

Vault is designed for regulated industries. If you can use Vault, you can pass a compliance audit.

No. Vault is self-hosted on your infrastructure. ODW.ai has zero access to your documents, queries, or embeddings.

Unlike cloud RAG platforms (Glean, Onyx), Vault doesn't send telemetry to a third party. Everything stays on your servers.

This is critical for sovereignty-focused organizations. You can't claim data sovereignty if your RAG tool is sending your documents to a cloud vendor.

Yes. Vault provides fine-grained access control (Enterprise tier):

• Knowledge base-level: Control who can access which knowledge bases (e.g., HR team can access "HR Policies", legal team can access "Legal Contracts")
• Document-level: Control who can access specific documents (e.g., only managers can access "Executive Compensation")
• Role-based: Assign roles (Admin, Editor, Viewer) with different permissions
• Attribute-based: Control access based on user attributes (department, clearance level, etc.)

Access control is enforced at query time — if a user doesn't have permission to access a document, Vault won't return it in query results.

Yes. Vault supports SSO (Single Sign-On) via SAML 2.0 and OIDC (Enterprise tier):

• Okta: Native integration
• Azure AD / Entra ID: Native integration
• Google Workspace: Native integration
• Other: Any SAML 2.0 or OIDC-compliant identity provider

SSO allows users to log in to Vault using their existing corporate credentials — no separate username/password to remember.

Yes. Vault is HIPAA-compatible:

• Self-hosted: PHI stays on your infrastructure — no data sent to third parties
• Encryption: AES-256 at rest, TLS 1.3 in transit
• Access control: RBAC, document-level permissions, audit logging
• Audit logging: Tamper-evident logs of all access to PHI
• BAA: If using ODW.ai-hosted Vault (Enterprise tier), we'll sign a Business Associate Agreement

Vault helps you meet the technical safeguards required by HIPAA. You still need to address administrative and physical safeguards separately.

Yes. Vault is GDPR-compatible:

• Data residency: All data stays on your infrastructure (or in your chosen region if using private cloud)
• Right to erasure: Delete documents and associated embeddings on request
• Right to access: Export user data on request
• Data processing records: Audit logs track all data processing activities

Vault helps you meet the technical and organizational measures required by GDPR (Article 32). You still need to address legal and procedural requirements separately.

Yes. Vault supports air-gapped deployment (no internet access):

• Offline installation: Install Vault without internet access (Docker images, offline packages)
• Local models: Run embedding and generation models on your own hardware (no API calls to external services)
• No external dependencies: Vault doesn't require internet access for updates, telemetry, or license validation

Air-gapped deployment is common for government contractors, military, and high-security environments.

Vault enforces access control at query time:

• Permission check: Before returning results, Vault checks if the user has permission to access each document
• Filtering: If a user doesn't have permission, the document is filtered out of results — they never see it
• Audit logging: All queries are logged (who queried what, when, and what results were returned)

Example: A junior employee queries "Show me executive compensation." If they don't have permission to access the "Executive Compensation" document, Vault returns no results — and the query is logged for audit purposes.

Vault is model-agnostic — it supports a wide range of models:

Embedding models:

• OpenAI: text-embedding-3-small, text-embedding-3-large
• Cohere: embed-english-v3.0, embed-multilingual-v3.0
• Local: sentence-transformers (all-MiniLM-L6-v2, all-mpnet-base-v2, etc.)
• Custom: Any model that exposes an OpenAI-compatible API

Generation models:

• Local: Llama 3, Mistral, Gemma, Qwen (via Ollama, vLLM, llama.cpp)
• API: OpenAI (GPT-4o, GPT-4o-mini), Anthropic (Claude 3.5 Sonnet), Google (Gemini 1.5 Pro)
• Custom: Any model that exposes an OpenAI-compatible API

You can switch models at any time — no code changes required.

Yes. Vault supports local models via:

• Ollama: Easiest way to run local models. Supports Llama 3, Mistral, Gemma, etc.
• vLLM: High-performance inference server for production workloads
• llama.cpp: Lightweight, CPU-friendly inference (good for edge devices)

Local models run on your own hardware — no data leaves your infrastructure. Full sovereignty.

Yes. Vault supports API-based models:

• OpenAI: GPT-4o, GPT-4o-mini, text-embedding-3-large
• Anthropic: Claude 3.5 Sonnet, Claude 3 Opus
• Google: Gemini 1.5 Pro
• Custom: Any model that exposes an OpenAI-compatible API

API-based models are useful when you need frontier capabilities (e.g., complex reasoning, long context windows) that local models can't match yet.

Yes. Vault supports per-task model routing:

• Simple queries: Use a fast, local model (e.g., Llama 3 8B) — fast, sovereign, cheap
• Complex queries: Use a powerful API model (e.g., GPT-4o) — more capable, but data leaves your infrastructure
• Custom routing: Define rules (e.g., "If query contains PHI, use local model only")

This gives you the best of both worlds: sovereignty for sensitive queries, capability for complex queries.

Choosing an embedding model depends on your priorities:

Recommendation:

• Maximum sovereignty: Use sentence-transformers (local, free)
• Maximum accuracy: Use OpenAI text-embedding-3-large or Cohere embed-v3 (API, paid)
• Balanced: Start with sentence-transformers, upgrade to OpenAI/Cohere if accuracy is poor

Choosing a generation model depends on your priorities:

Recommendation:

• Maximum sovereignty: Use Llama 3 8B or 70B (local, free)
• Maximum quality: Use GPT-4o or Claude 3.5 Sonnet (API, paid)
• Balanced: Use Llama 3 8B for simple queries, GPT-4o-mini for complex queries

Not in Vault v1. Vault uses existing models — it doesn't support fine-tuning.

However, you can:

• Use retrieval: RAG is often more effective than fine-tuning for domain-specific knowledge. Instead of fine-tuning the model on your documents, just retrieve the relevant documents at query time.
• Prompt engineering: Customize the system prompt to guide the model's behavior (e.g., "You are a legal assistant. Answer questions based on the provided legal documents.")
• Fine-tune externally: Fine-tune a model outside of Vault (using tools like Hugging Face Transformers), then use the fine-tuned model in Vault via a custom endpoint.

Fine-tuning support is planned for v2.0 (Q2 2027).

Yes. Vault is model-agnostic — you can switch models at any time:

• No code changes: Just update the model configuration in the admin console
• No re-embedding: If you switch generation models, you don't need to re-embed your documents (embeddings are model-specific, but you can keep using the old embeddings or re-embed with the new model)
• Per-query switching: Use different models for different queries (e.g., local model for simple queries, API model for complex queries)

This future-proofs your investment — when better models are released, you can adopt them immediately without re-architecting your system.

Vault offers three deployment options:

1. Docker Compose: Easiest. One command (docker-compose up) and you're running. Best for development and small deployments.
2. Kubernetes (Helm): Production-ready. Helm chart provided. Best for large deployments, high availability, auto-scaling.
3. Bare metal: For advanced users. Install directly on Linux servers. Maximum control, but requires more setup.

For most customers, Docker Compose is the fastest path. For production, we recommend Kubernetes.

Setup time depends on your deployment:

• Docker Compose: 30 minutes. Pull images, configure environment variables, run docker-compose up.
• Kubernetes: 2-4 hours. Deploy Helm chart, configure ingress, set up storage, test.
• Bare metal: 1-2 days. Install dependencies, configure services, test.

Target: <4 hours from download to first query (for Docker Compose deployment).

For deployment: Yes. Vault is self-hosted, so you need someone who can manage Docker/Kubernetes, configure networking, and monitor infrastructure. This is typically a DevOps engineer or IT consultant.

For day-to-day use: No. The admin console is designed for non-technical users (knowledge managers, compliance officers). You can upload documents, create knowledge bases, and query the system without writing code.

For developers: Vault provides a REST API and SDKs (Python, JavaScript) for custom integrations. Developers can build custom workflows, integrate Vault into internal tools, etc.

Vault's requirements depend on your deployment:

If you use API-based models (OpenAI, Anthropic), you don't need a GPU. If you use local models, GPU is strongly recommended.

Yes. Vault can be deployed on any cloud provider:

• AWS: Use EC2 (for Docker Compose) or EKS (for Kubernetes). Use S3 for document storage, RDS for metadata.
• GCP: Use GCE (for Docker Compose) or GKE (for Kubernetes). Use GCS for document storage, Cloud SQL for metadata.
• Azure: Use VMs (for Docker Compose) or AKS (for Kubernetes). Use Blob Storage for document storage, Azure SQL for metadata.

We provide deployment guides for each cloud provider. For production, we recommend Kubernetes with managed databases (RDS, Cloud SQL, Azure SQL).

Yes. Vault provides migration tools:

• Import documents: Upload your existing documents (PDF, DOCX, etc.)
• Import embeddings: If your previous platform exported embeddings, you can import them (if they use the same embedding model)
• Re-embedding: If embeddings aren't compatible, Vault can re-embed your documents (takes time, but ensures accuracy)

Migration typically takes 1-2 weeks. We provide migration guides and support for common platforms (Glean, Onyx, PrivateGPT).

Vault is configured via the admin console (web-based UI) or environment variables:

• Model providers: Configure embedding and generation models (local or API)
• Storage: Configure document storage (local, S3, GCS, Azure Blob)
• Database: Configure metadata database (PostgreSQL, MySQL)
• Vector database: Configure vector storage (Qdrant, Weaviate, Milvus, Chroma)
• Authentication: Configure SSO, RBAC (Enterprise tier)

Most configuration is done through the UI. For advanced users, Vault also supports configuration via YAML files or environment variables.

Yes. Vault includes a sandbox mode:

• Test environment: Deploy Vault in a test environment with sample documents
• Experiment: Test different models, chunking strategies, and retrieval configurations
• Evaluate: Measure accuracy, latency, and cost before going live

We recommend spending 1-2 days testing in sandbox mode before deploying to production.

Vault pricing is based on deployment mode and features:

Additional costs:

• API costs: If you use API-based models (OpenAI, Anthropic), you pay the API provider directly
• Infrastructure: You pay for your own servers/cloud (if self-hosting)

Yes, significantly. Glean and Onyx typically cost $10-$30/user/month. For a 100-person company, that's $1,000-$3,000/month.

Vault costs $0-$499/month (flat rate, not per user). For a 100-person company, Vault is 2-30x cheaper.

And Vault is self-hosted — you get full sovereignty. Glean/Onyx are cloud SaaS — you send them your documents.

Of course, Glean/Onyx are managed services (no infrastructure to manage), while Vault requires self-hosting. But if you have the infrastructure and need sovereignty, Vault is the clear winner on cost.

No hidden costs. The total cost of ownership includes:

• Vault subscription: Monthly fee based on tier (or $0 for Community)
• API costs: If you use API-based models (OpenAI, Anthropic), you pay the API provider directly
• Infrastructure: You pay for your own servers/cloud (if self-hosting)

That's it. No setup fees, no surprise charges, no per-user fees.

Yes. The Community tier is 100% free:

• No time limit: Use it forever
• No feature limits: All core features included (document ingestion, RAG, API, etc.)
• No user limits: Unlimited users
• No document limits: Unlimited documents

The only limitations:

• Enterprise features: SSO, advanced RBAC, audit logging, compliance features are paid
• Support: Community support only (GitHub issues, Discord). No email or priority support.

We believe in open source. If you don't need enterprise features, you can use Vault for free forever.

We accept:

• Credit/debit cards: Visa, Mastercard, American Express (via Stripe)
• Bank transfer: For annual subscriptions or enterprise customers
• Cryptocurrency: Bitcoin, Ethereum, USDC (for privacy-conscious customers)

Invoicing is available for annual subscriptions. Contact us for details.

Yes. We offer a 30-day money-back guarantee. If you're not satisfied within the first 30 days, contact us for a full refund — no questions asked.

After 30 days, you can cancel anytime. You'll continue to have access until the end of your billing period, but no refund is provided for partial months.

Yes. Vault is part of the ODW.ai suite. You can:

• Purchase Vault standalone: Use Vault by itself (for knowledge retrieval)
• Purchase the full suite: Get Desk, Voice, Vault, Shield, and other modules at a discounted price

The suite bundle includes Vault at a 20-30% discount compared to purchasing separately. And all modules integrate natively — Vault serves as the knowledge backend for Desk, Voice, and other modules.

Vault scales horizontally:

• Small deployments: 1,000-10,000 documents (Docker Compose, single node)
• Medium deployments: 10,000-100,000 documents (Kubernetes, 3+ nodes)
• Large deployments: 100,000-1,000,000+ documents (Kubernetes, auto-scaling, distributed vector database)

For very large deployments (1M+ documents), we recommend:

• Distributed vector database (Qdrant cluster, Milvus cluster)
• Managed PostgreSQL (RDS, Cloud SQL)
• Auto-scaling Kubernetes cluster

Vault supports unlimited users (no per-user limits):

• Community tier: Unlimited users
• Pro tier: Unlimited users
• Enterprise tier: Unlimited users

Vault scales horizontally — add more nodes to handle more concurrent users. Typical deployments support 100-1,000 concurrent users per node.

If Vault goes down, query functionality is unavailable, but your documents are safe:

• Documents: Stored in your database (PostgreSQL) and vector database (Qdrant, Weaviate, etc.) — not lost
• Recovery: Restart Vault, and it reconnects to your databases
• High availability: For production, deploy Vault with multiple replicas (Kubernetes) and a managed database (RDS, Cloud SQL)

For high-availability deployments, we recommend:

• Kubernetes: 3+ replicas across availability zones
• Managed database: RDS, Cloud SQL, or Azure SQL (99.9% uptime SLA)
• Load balancer: Distribute traffic across replicas

Vault includes a monitoring dashboard:

• System health: CPU, memory, disk, network usage
• Query metrics: Number of queries per second, latency (p50, p95), error rate
• Document metrics: Number of documents, chunks, embeddings
• Model metrics: API costs, token usage, model latency

You can also export metrics to external monitoring tools (Prometheus, Grafana, Datadog) via standard protocols.

Vault data is stored in two places:

• Metadata database: PostgreSQL (document metadata, user data, etc.). Back up using standard PostgreSQL tools (pg_dump, WAL archiving).
• Vector database: Qdrant, Weaviate, Milvus, or Chroma (embeddings). Back up using the vector database's native backup tools.
• Documents: Stored in file system or object storage (S3, GCS, Azure Blob). Back up using standard file/object storage backup tools.

We recommend:

• Daily backups: Automated backups of all three components
• Off-site storage: Store backups in a different location (e.g., S3, GCS, off-site server)
• Test restores: Periodically test restoring from backups to ensure they work

Yes. Vault supports multi-tenancy:

• Knowledge bases: Create separate knowledge bases for different teams or departments (e.g., "HR", "Engineering", "Legal")
• Access control: Control who can access which knowledge bases (Enterprise tier)
• Isolation: Each knowledge base has its own documents, embeddings, and permissions
• Query scope: Query a specific knowledge base or search across all knowledge bases

This is useful for organizations with strict data separation requirements or multi-tenant deployments (e.g., MSPs managing multiple customers).

Vault is designed to be intuitive, but we provide training resources:

• Documentation: Comprehensive user guides for admins, knowledge managers, and end users
• Video tutorials: Step-by-step walkthroughs of key features
• Onboarding session: For paid customers, we offer a 1-hour onboarding session (remote)
• Support: Priority support for Pro and Enterprise customers

Most teams are productive within 1-2 hours of training. The web UI is particularly intuitive — no technical skills required for end users.

Vault integrates natively with all ODW.ai products:

• Desk: Uses Vault as the knowledge backend for customer support AI
• Voice: Uses Vault as the knowledge backend for voice assistant
• Shield: Vault emits audit logs to Shield for governance and compliance
• Other modules: Any ODW.ai module that needs knowledge retrieval uses Vault

If you're using the ODW.ai suite, Vault integration is automatic — no separate configuration required.

Yes. Vault provides a REST API for programmatic access:

• Document management: Upload, delete, and manage documents via API
• Query: Send queries and retrieve results via API
• Knowledge base management: Create, delete, and manage knowledge bases via API
• Admin: Configure models, chunking strategies, and other settings via API

The API is fully documented (OpenAPI/Swagger) and supports authentication via API keys or OAuth 2.0.

Yes. Vault provides SDKs for popular languages:

• Python: pip install odw-vault
• JavaScript/TypeScript: npm install @odw/vault

SDKs wrap the REST API and provide a more convenient interface for developers:

from odw_vault import VaultClient

client = VaultClient(api_key="your-api-key")
results = client.query("What's our refund policy?", knowledge_base="hr-policies")
print(results.answer)

SDKs are open source and available on GitHub.

Yes. Vault can be integrated with internal tools via:

• REST API: Call Vault's API from your internal tools (web apps, mobile apps, scripts)
• SDKs: Use Python or JavaScript SDKs for easier integration
• Webhooks: Vault can send webhooks when documents are added/updated/deleted (for event-driven workflows)

Common integrations:

• Slack: Build a Slack bot that queries Vault
• Microsoft Teams: Build a Teams bot that queries Vault
• Internal web apps: Embed Vault's query UI in your internal portal
• Custom workflows: Use Vault's API in automated workflows (e.g., auto-summarize new documents)

Yes. Vault includes a connector framework for external data sources:

• SharePoint: Sync documents from Microsoft SharePoint (Enterprise tier)
• Google Drive: Sync documents from Google Drive (Enterprise tier)
• Confluence: Sync pages from Atlassian Confluence (Enterprise tier)
• File system: Sync documents from local or network drives
• S3-compatible: Sync from AWS S3, MinIO, or other S3-compatible storage
• Custom: Build your own connector using the connector SDK

Connectors can sync on a schedule (e.g., every hour) or in real-time (via webhooks).

Yes. Vault provides an embeddable query widget:

• JavaScript widget: Embed a chat-style query UI in your website or web app
• Customizable: Customize the widget's appearance (colors, logo, etc.) to match your brand
• Authentication: Widget respects Vault's access control — users only see documents they have permission to access

This is useful for:

• Customer-facing: Embed a knowledge base in your customer portal
• Employee-facing: Embed a knowledge base in your internal portal
• Product integration: Embed Vault's query UI in your product as a feature

Yes. Vault can be used with existing AI tools:

• LangChain: Use Vault as a retriever in LangChain pipelines
• LlamaIndex: Use Vault as a retriever in LlamaIndex pipelines
• Custom RAG: Use Vault's API in your custom RAG pipelines

Vault is designed to be a knowledge layer — it provides retrieval, and you can use any AI tool for generation.

Vault is powerful, but it has limitations in v1.0:

• No real-time streaming: Vault supports batch and near-real-time ingestion, but not sub-second streaming
• No mobile apps: No native iOS/Android apps (web UI is mobile-friendly, but no native apps)
• No voice/audio ingestion: Can't ingest audio files (e.g., meeting recordings) — text only
• No video analysis: Can't analyze video content
• No workflow automation: Vault is a knowledge layer, not a workflow engine (use other ODW.ai modules for that)
• English-only UI: UI is English-only (v1) — multi-language UI planned for v1.1
• No model fine-tuning: Vault uses existing models — can't fine-tune models (planned for v2.0)

Yes. We're adding support for more document formats in v1.1 (Q4 2026):

• PPTX: PowerPoint presentations
• XLSX: Excel spreadsheets
• Email formats: EML, MSG (Outlook)
• OCR: Improved OCR for scanned PDFs and images

If you need a specific format, let us know — we prioritize based on customer demand.

Planned for v1.2 (Q1 2027). Voice/audio ingestion will include:

• Transcription: Automatically transcribe audio files (meeting recordings, voice memos) using Whisper or other ASR models
• Speaker diarization: Identify who said what in meeting recordings
• Searchable transcripts: Ingest transcripts into Vault for retrieval

This is a high-priority feature for customers who want to search meeting recordings and voice memos.

Planned for v1.1 (Q4 2026). Multi-language UI will include:

• Chinese (Simplified and Traditional)
• Spanish
• French
• German
• Japanese

The query engine already supports multi-language documents and queries — only the UI is English-only in v1.

Key milestones:

• v1.0 (Q3 2026): MVP launch. Document ingestion, RAG, model-agnostic inference, multi-tenancy, REST API, SDKs.
• v1.1 (Q4 2026): Additional document formats (PPTX, XLSX, email), multi-language UI, improved OCR.
• v1.2 (Q1 2027): Voice/audio ingestion (transcription, speaker diarization), advanced analytics.
• v2.0 (Q2 2027): Model fine-tuning, advanced retrieval strategies (hybrid search, re-ranking), workflow automation.

Roadmap is subject to change based on customer feedback. Contact us for the latest roadmap or to request features.

Vault is not the right fit if:

• You don't have sovereignty requirements: If you don't care about data sovereignty, cloud RAG platforms (Glean, Onyx) are easier (no infrastructure to manage).
• You need real-time streaming: Vault supports batch and near-real-time ingestion, but not sub-second streaming. If you need real-time, use a dedicated streaming platform.
• You need workflow automation: Vault is a knowledge layer, not a workflow engine. If you need complex workflows, use a dedicated workflow tool (or other ODW.ai modules).
• You need a chatbot UI: Vault provides the knowledge layer, but not a polished chatbot UI. If you need a turnkey chatbot, use a dedicated chatbot platform (or integrate Vault with your own UI).

No. No AI system can guarantee 100% accuracy. Vault's accuracy depends on:

• Document quality: Clear, well-structured documents = better accuracy
• Embedding model: Better embedding models = better retrieval
• Generation model: Better generation models = better answers
• Query clarity: Clear, specific questions = better answers

Target: ≥85% MRR@10 (Mean Reciprocal Rank at 10). This means the correct answer is in the top 10 results 85% of the time.

Vault provides source citations so you can verify answers. If accuracy is poor, try improving document quality, switching to a better model, or rephrasing queries.

Three paths:

1. Free trial: Download Vault and deploy it yourself. No credit card required. Try it with your documents and see if it works for your use case.
2. Demo: Book a demo with our team. We'll walk you through Vault, answer your questions, and help you evaluate if it's right for your business.
3. Contact sales: For enterprise customers or custom deployments (on-premises, air-gapped), contact our sales team for a tailored quote.