Docify: The Local AI Research Tool

Tired of losing track of research papers? Drowning in browser tabs and PDFs? Meet Docify—the privacy-first AI assistant that remembers everything you've ever read and gives you cited answers instantly. No cloud required.

In this deep dive, you'll discover how Docify's local RAG pipeline transforms your document chaos into a searchable second brain. We'll walk through real code examples, advanced configurations, and battle-tested strategies that power users swear by. Whether you're a researcher drowning in academic papers, a developer managing technical docs, or a knowledge worker building a personal wiki—Docify delivers enterprise-grade AI without compromising your data.

Ready to reclaim your research workflow? Let's explore the architecture, setup, and pro tips that make Docify the most exciting open-source AI project of 2024.

What is Docify?

Docify is an open-source, local-first AI application that functions as your personal research assistant. Created by developer Keshav Ashiya, it addresses a critical gap in the AI tooling landscape: powerful document analysis without surveillance capitalism.

At its core, Docify implements a Retrieval-Augmented Generation (RAG) pipeline that ingests documents, generates embeddings, and answers questions with verifiable citations. Unlike cloud-based solutions that harvest your data, Docify runs entirely on your machine using Docker containers.

The project exploded in popularity because it solves three pain points simultaneously: privacy, accuracy, and usability. While tools like ChatGPT require you to upload sensitive documents to external servers, Docify processes everything locally using Ollama's Mistral 7B model. Every answer includes citations linking back to source documents, eliminating AI hallucinations.

Docify's architecture integrates 11 specialized services that work in concert: resource ingestion, smart chunking, async embeddings, hybrid search, re-ranking, and citation verification. This modular design makes it both powerful for end-users and hackable for developers who want to customize their pipeline.

The timing couldn't be better. With increasing concerns about AI data privacy and the rise of local LLMs, Docify represents a paradigm shift. It's not just another chatbot wrapper—it's a complete research infrastructure that you own completely.

Key Features That Make Docify Stand Out

🔒 Privacy-First Architecture Every component runs locally. Your PDFs, URLs, Word documents, and code never leave your machine. Embeddings are generated using local models, storage uses PostgreSQL with pgvector, and the LLM runs via Ollama. This isn't just a feature—it's the foundation.

🧠 Smart Deduplication Engine Docify uses content-based fingerprinting to prevent duplicate processing. If you upload the same research paper twice, it recognizes the content and skips re-processing. This saves compute cycles and keeps your vector database clean. The fingerprinting algorithm creates a unique hash based on document content, not filename.

📚 Multi-Format Ingestion Pipeline The ingestion system handles PDFs, URLs, Word docs, Excel sheets, Markdown, images with OCR, and code files. Each format has a dedicated parser that extracts text while preserving semantic structure. Images undergo OCR using Tesseract, and code files maintain syntax highlighting metadata.

💬 Citation-Backed Answers Every AI response includes inline citations linking to specific document sections. This isn't just bibliography—it's clickable references that show exactly where information came from. The system implements a 5-factor re-ranking score that evaluates relevance, freshness, authority, coverage, and conflict detection.

🔍 Hybrid Search System Docify combines semantic vector search with traditional BM25 keyword search. This dual approach captures both conceptual similarity and exact term matches. The system uses query expansion to generate search variants, improving recall by 40% compared to single-method search.

🤖 Flexible LLM Support While optimized for Mistral 7B via Ollama, Docify supports OpenAI and Anthropic APIs. The prompt engineering layer includes anti-hallucination templates that force the model to stay grounded in retrieved context. Token budget management ensures you never exceed context limits.

🌐 Workspace Collaboration Choose between personal, team, or hybrid workspaces. Each workspace has isolated vector stores and access controls. This makes Docify suitable for both individual researchers and small teams who need shared knowledge bases without corporate surveillance.

🚀 One-Command Setup The ./scripts/setup.sh script orchestrates everything: prerequisite checks, environment configuration, Docker service initialization, database setup, and model downloads. Most users are up and running in 10-15 minutes.

Real-World Use Cases Where Docify Shines

Academic Research & Literature Review

Problem: You're writing a thesis and have 200+ papers scattered across folders. Finding that one statistic or methodology reference takes hours.

Docify Solution: Upload all papers to a workspace. Ask "What datasets were used in transformer efficiency studies from 2022-2023?" Docify returns cited answers pointing to exact paper sections. The hybrid search catches both "transformer" (semantic) and "BLEU score" (keyword). Smart deduplication prevents re-processing when you add new papers to your collection.

Legal Document Analysis

Problem: Reviewing contracts, case law, and regulatory documents requires pinpoint accuracy. Missing a clause can be catastrophic.

Docify Solution: Create a workspace per case. Upload contracts, precedents, and regulations. Query "Show me all non-compete clauses with geographic restrictions" and get verbatim excerpts with document citations. The local processing ensures client confidentiality. Conflict detection highlights contradictory clauses across documents.

Developer Documentation Management

Problem: Your team uses 15 different tools with documentation in GitHub wikis, Confluence, PDFs, and READMEs. Finding API specs is a nightmare.

Docify Solution: Ingest all documentation into a team workspace. Ask "What's the authentication flow for the payments API?" Docify searches across formats, finds the relevant code examples and API docs, and synthesizes a coherent answer with links to sources. The OCR feature extracts text from architecture diagrams.

Competitive Intelligence & Market Research

Problem: You're tracking competitors across websites, whitepapers, and conference presentations. Information lives in browser bookmarks and screenshots.

Docify Solution: Scrape competitor sites, upload whitepapers, OCR presentation slides. Query "How does Acme Corp price their enterprise tier?" Docify extracts pricing mentions, feature comparisons, and case studies. The workspace model lets you segment by competitor. Freshness scoring prioritizes recent information.

Step-by-Step Installation & Setup Guide

Prerequisites Check

Before starting, verify your system meets these requirements:

• Docker & Docker Compose installed and running
• 8GB RAM minimum (16GB recommended for smooth operation)
• 20GB free disk space (models and vector database need room)
• Internet connection for initial model download (~4GB)

One-Command Setup (Recommended)

For macOS and Linux users, open your terminal and execute:

# Clone the repository
git clone https://github.com/keshavashiya/docify.git
cd docify

# Run the automated setup script
./scripts/setup.sh

For Windows PowerShell users:

# Clone the repository
git clone https://github.com/keshavashiya/docify.git
cd docify

# Run the automated setup script
.\scripts\setup.ps1

What the Setup Script Does

The setup script is a masterpiece of automation. Here's what happens behind the scenes:

1. Prerequisite Validation: Checks Docker daemon, available memory, and disk space
2. Environment Generation: Creates .env file from .env.example with sensible defaults
3. Docker Orchestration: Builds and starts all 11 services using Docker Compose
4. Database Initialization: Creates pgvector extension in PostgreSQL
5. Model Download: Pulls mistral:7b-instruct-q4_0 and all-minilm:22m (~4GB total)
6. Health Verification: Runs integration tests to confirm all services communicate

Pro Tip: The first run takes 10-15 minutes depending on your internet speed. Subsequent starts using ./scripts/start.sh take under 30 seconds.

Setup Options for Power Users

# Skip model download for faster setup (if you already have models)
./scripts/setup.sh --skip-models

# Reset everything—wipes database and starts fresh
./scripts/setup.sh --reset

# Show all available options
./scripts/setup.sh --help

Daily Usage Commands

After successful setup, use these commands:

# Start Docify (quick daily startup)
./scripts/start.sh

# Start and follow logs in real-time
./scripts/start.sh --logs

# Stop all services gracefully
./scripts/start.sh --stop

# Check service health status
./scripts/start.sh --status

Access Points

Once running, access Docify through:

• Web Interface: http://localhost:3000
• API Documentation: http://localhost:8000/docs (Swagger UI)
• Health Check: http://localhost:8000/api/health

Verification Steps

Run these commands to verify your installation:

# Check all containers are healthy
docker-compose ps

# Test API health endpoint
curl http://localhost:8000/api/health

# Monitor resource usage
docker stats docify-ollama docify-backend

# View backend logs for any errors
docker-compose logs -f backend

REAL Code Examples from the Repository

Example 1: Automated Setup Script Execution

This is the exact command from Docify's README that orchestrates the entire installation:

# Clone the repository
git clone https://github.com/keshavashiya/docify.git
cd docify

# Run the setup script (handles everything!)
./scripts/setup.sh

Explanation: The setup.sh script is a bash orchestrator that eliminates manual configuration. It checks for Docker, validates system resources, creates environment files, starts services, and downloads models. The magic lies in its idempotency—running it multiple times won't break anything. It uses health checks and retry logic to handle race conditions between services.

Example 2: Uploading a Resource via API

Once Docify is running, programmatically upload documents using the REST API:

curl -X POST "http://localhost:8000/api/resources/upload" \
  -F "file=@research_paper.pdf" \
  -F "workspace_id=<your-workspace-id>"

Line-by-Line Breakdown:

• -X POST: HTTP POST method to send data
• http://localhost:8000/api/resources/upload: Endpoint for resource ingestion
• -F "file=@research_paper.pdf": Multipart form data specifying the file to upload
• -F "workspace_id=<your-workspace-id>": Associates the document with a specific workspace

Implementation Pattern: This endpoint triggers the full ingestion pipeline—parsing, chunking, deduplication, and async embedding generation. The response includes a resource ID you can use to track processing status.

Example 3: Semantic Search with Citations

Search your knowledge base with hybrid retrieval:

curl -X POST "http://localhost:8000/api/search" \
  -H "Content-Type: application/json" \
  -d '{"query": "What is RAG?", "workspace_id": "<id>"}'

Technical Deep Dive: The search endpoint implements a sophisticated RAG pipeline:

1. Query Expansion: Generates 3-5 semantic variants of "What is RAG?"
2. Hybrid Retrieval: Runs vector similarity search AND BM25 keyword search in parallel
3. Re-Ranking: Applies 5-factor scoring (relevance, recency, authority, coverage, conflict)
4. Context Assembly: Builds context within token budget, prioritizing diverse sources
5. Citation Mapping: Tracks which chunks contributed to each part of the answer

Response Format: Returns JSON with answer, citations[], confidence_score, and source_chunks[].

Example 4: Conversational Q&A with Message History

Ask follow-up questions in a conversation thread:

curl -X POST "http://localhost:8000/api/conversations/<id>/messages" \
  -H "Content-Type: application/json" \
  -d '{"content": "Explain the main findings", "role": "user"}'

Advanced Usage: This endpoint maintains conversation context. The <id> is your conversation thread identifier. Docify retrieves relevant documents, includes conversation history in the prompt, and generates cited answers. The role field can be "user" or "assistant" for multi-turn dialogues.

Pro Tip: Use this for iterative research. Start broad ("What methods were used?"), then drill down ("Compare method X and Y") with full context retention.

Example 5: Docker Troubleshooting Commands

Monitor and debug your Docify installation:

# Check what's using port 8000 (Docify backend)
lsof -i :8000

# View real-time logs for the Celery worker
docker-compose logs -f celery-worker

# Restart backend after configuration changes
docker-compose restart backend

# Stop everything and wipe data (NUCLEAR OPTION)
docker-compose down -v

Production Insights: The celery-worker logs are gold for debugging ingestion issues. You'll see chunking decisions, embedding generation times, and deduplication hits. The -v flag in docker-compose down -v destroys ALL data—use only when you want a complete reset.

Advanced Usage & Best Practices

Optimize Model Performance

Quantization Matters: Docify uses mistral:7b-instruct-q4_0—a 4-bit quantized model. This balances quality and speed on consumer hardware. If you have a GPU, edit .env to use mistral:7b-instruct for better accuracy.

Embedding Model Selection: The default all-minilm:22m is fast but small. For better semantic search, consider nomic-embed-text or mxbai-embed-large. Update the EMBEDDING_MODEL environment variable.

Chunking Strategy Tuning

Docify uses semantic boundary preservation—it splits documents at logical breakpoints (paragraphs, sections) rather than fixed sizes. For technical docs, increase chunk overlap in backend/app/core/config.py:

CHUNK_SIZE = 512  # Tokens per chunk
CHUNK_OVERLAP = 50  # Overlap for context continuity

Workspace Organization

Personal: One workspace per research project. Keeps vectors isolated and relevant.

Team: Use shared workspaces with naming conventions: team-product-docs, team-competitive-intel.

Hybrid: Personal workspace for drafts, team workspace for finalized knowledge.

Scaling for Large Collections

• Batch Upload: Use the API to upload multiple files in parallel
• Async Monitoring: Poll the /api/resources/<id>/status endpoint to track processing
• Database Indexing: For >100k documents, add composite indexes on workspace_id and created_at

Security Hardening

• Change Default Ports: Edit docker-compose.yml to use non-standard ports
• API Keys: Even though it's local, add API key middleware for team deployments
• Backup Strategy: Regularly backup the PostgreSQL volume: docker-compose exec postgres pg_dump > backup.sql

Comparison with Alternatives

Why Docify Wins: The combination of smart deduplication, hybrid search, and citation verification creates a research-grade tool. While privateGPT is simpler, it lacks the sophisticated RAG pipeline. Obsidian AI plugins require cloud APIs. Quivr and AnythingLLM are powerful but don't match Docify's deduplication and conflict detection.

Best For: Researchers and developers who need provable accuracy and data sovereignty.

Frequently Asked Questions

Q: How much RAM do I really need? A: 8GB is the absolute minimum. With 16GB, you'll experience smooth performance even with 50k+ documents. The Ollama service uses ~4GB, PostgreSQL uses 2GB, and the rest is overhead.

Q: Can I use my own LLM models? A: Absolutely! Edit the OLLAMA_MODEL variable in .env. Any GGUF model compatible with Ollama works. For GPU acceleration, set OLLAMA_GPU_LAYERS to the number of layers to offload.

Q: How does Docify handle document updates? A: When you re-upload a document, the fingerprinting algorithm detects changes. Only modified sections are re-processed. Version history is maintained at the chunk level.

Q: Is my data really private? A: Yes. Nothing leaves your machine. No telemetry, no analytics, no cloud sync. The only network activity is initial model download from Ollama's servers. You can verify this by monitoring network traffic.

Q: What's the maximum document size? A: The default upload limit is 50MB per file. For larger documents, increase MAX_UPLOAD_SIZE in the backend config. The chunking system handles 1000+ page PDFs by processing them in streaming fashion.

Q: Can I export my data? A: Yes! Use the API to export workspaces as JSON, or backup the PostgreSQL volume directly. The vector embeddings are portable and can be migrated to other pgvector instances.

Q: How accurate are the citations? A: Docify implements claim verification—each statement in the answer is cross-referenced against source chunks. The confidence score reflects citation strength. In testing, accuracy exceeds 95% for well-structured documents.

Conclusion: Why Docify Belongs in Your Toolkit

Docify isn't just another AI tool—it's a paradigm shift in how we interact with our personal knowledge. By combining local-first architecture with a sophisticated RAG pipeline, it delivers something unique: provable, private, powerful research assistance.

The one-command setup democratizes AI infrastructure that previously required ML engineering expertise. The citation system builds trust. The workspace model scales from individual to team use. Most importantly, the privacy guarantee means you can analyze sensitive documents without corporate oversight.

I've tested dozens of RAG tools, and Docify's deduplication engine and hybrid search are genuinely best-in-class. The ability to ask complex questions across hundreds of documents and get cited answers in seconds feels like magic—except it's running on your laptop.

The bottom line: If you value your data privacy and need research-grade AI, Docify is non-negotiable. It's the tool I wish I had during my PhD, and it's the tool I'm using now for competitive intelligence.

Ready to build your second brain?

🚀 Clone Docify on GitHub and run ./scripts/setup.sh today. Your future self will thank you.

Join the growing community of researchers, developers, and privacy advocates who've made Docify their research command center. The future of AI is local—and it's here.