Insight

An AI research assistant for journalists. Your documents stay on your computer.

Why Insight?

Newsrooms deal with mountains of documents—court filings, FOIA responses, leaked files—but searching and analyzing them usually means uploading to cloud services you may not trust.

Insight is different. Your documents are processed and stored locally—they never leave your computer unless you choose to share them with a colleague. You can run the AI entirely on your machine, or use cloud models (Anthropic, OpenAI) for the chat while keeping your documents local.

What Can It Do?

• Answer questions about your documents — Ask in plain language, get answers with citations pointing to the exact source.
• Search smarter — Finds relevant content even when you don’t know the exact words to search for.
• Share securely — Send collections directly to colleagues, laptop-to-laptop, without a server in between.
• Work offline — Once set up, no internet needed.

Quick Start

1. Download Insight for your computer
2. Create a collection and add your documents
3. Start asking questions

See Getting Started for step-by-step instructions.

Getting Started

Download

Which file do I download?

• macOS: Download the .dmg file. Choose aarch64 for newer Macs (M1/M2/M3/M4) or x64 for older Intel Macs.
• Windows: Download the .exe installer. (IT departments may prefer the .msi.)
• Linux: Download .deb for Ubuntu/Debian, .rpm for Fedora/Red Hat, or .AppImage to run on any distribution.

Choosing an AI Model

Insight can use either local AI models or cloud services for chat. Your documents are always processed locally—only your questions and the AI’s answers go through the cloud if you choose that option.

Cloud Models (Recommended for most users)

If you have an API key from Anthropic or OpenAI, you can use their models. Add your key in settings. This is the easiest option and works well on any computer.

You don’t need the biggest model. Smaller models like GPT-5 mini or Claude Haiku work well with Insight’s agent—they’re faster, cheaper, and handle document research tasks effectively. The agent harness does the heavy lifting of breaking down queries and gathering evidence, so even lightweight models produce good results.

Local Models

Running AI locally requires a powerful computer—ideally with a dedicated GPU (NVIDIA or Apple Silicon). On a typical laptop without a GPU, responses will be slow.

If you choose local models, Insight will download about 5 GB for the AI model on first use.

Create a Collection

Collections are folders for organizing your documents. You might create one for each investigation or story you’re working on.

1. Click New Collection
2. Give it a name (e.g., “City Budget Investigation”)
3. Drag and drop PDF files into the collection

Insight will process each document so the AI can search and read them.

Ask Questions

Once your documents are processed, just ask questions in plain language:

• “What was the total spending on consultants?”
• “Find all mentions of Company X”
• “Summarize the main findings from these reports”

The AI will search through your documents, find relevant passages, and give you an answer with citations you can click to see the original source.

Collections

Collections are how Insight organizes your documents. Think of them as folders—each collection holds a set of related documents with its own search and sharing settings.

Creating a Collection

Click New Collection and give it a name. You might organize by:

• Investigation (e.g., “City Hall Contracts”)
• Beat (e.g., “Climate”, “Housing”)
• Source type (e.g., “Court Documents”, “FOIA Responses”)

Adding Documents

Drag and drop PDF files into a collection, or click Add Files.

When you add a document, Insight:

1. Extracts the text so the AI can read it
2. Prepares it for searching
3. Stores everything locally on your computer

Sharing with Colleagues

You can share collections directly with other Insight users—no cloud upload required.

To Share

1. Open the collection
2. Click Share
3. Send the generated link to your colleague

To Join

1. Click Join Collection
2. Paste the link you received
3. Documents will copy to your computer automatically

Once synced, you both have full copies. You can work offline and still access everything.

Revoking Access

Insight uses capability-based sharing—when you share a collection, you give someone a cryptographic key that grants access. This has an important implication:

You cannot revoke access once shared.

Once someone has the key:

• They keep any documents already synced to their computer
• They can continue syncing with other peers who have the collection
• There’s no central server that can block their access

This is a fundamental tradeoff of decentralized systems: you get privacy and no single point of failure, but you lose centralized control.

If you need to stop sharing with someone:

1. Create a new collection
2. Copy the documents you want to keep sharing
3. Share the new collection only with trusted colleagues
4. Stop using the old collection

For sensitive material, consider who truly needs access before sharing. Once shared, assume the recipient has permanent access to everything in that collection.

Chat

Insight uses AI to help you find and understand information in your documents. Just ask questions in plain language—the AI does the searching for you.

How It Works

When you ask a question:

1. The AI figures out what you’re looking for
2. It searches your documents to find relevant passages
3. It reads through what it finds
4. It gives you an answer with citations

You don’t need to know which document contains the answer. Just ask, and the AI will find it.

Example Questions

Finding facts:

• “What was the total budget for 2023?”
• “Who approved the permit?”
• “When did the meeting take place?”

Summarizing:

• “Summarize the key findings from these reports”
• “What are the main arguments in this brief?”

Comparing:

• “How do the 2020 and 2023 assessments differ?”
• “Find contradictions between these statements”

Exploring:

• “What topics are covered in this collection?”
• “Find all mentions of Company X”

Citations

Every answer includes citations. Click one to jump straight to that passage in the original document—so you can verify and quote accurately.

Privacy Note

When using cloud models, your questions and relevant document excerpts are sent to the provider. Your full documents stay on your computer. See Getting Started for model options.

Architecture

Insight is built as a Tauri 2.0 desktop application with a Rust backend and Svelte frontend.

Core Stack

Agent Architecture

User Query
    ↓
Local LLM (via mistralrs)
    ↓
Tool Calling Loop
    ↓
Synthesized Answer (with citations)

The agent has tools for searching and reading documents. It iteratively gathers evidence to answer questions, citing sources along the way. There is no direct user-facing search—all document retrieval happens through the agent.

Data Model

Collections as Namespaces

Each collection is an iroh-docs namespace. Sharing a collection means sharing namespace access.

Namespace: 7f3a8b2c... ("Climate Research")
│
├── files/abc123     → blob with metadata JSON
├── files/def456     → blob with metadata JSON
└── _collection      → blob with collection settings

Document Metadata

Document metadata is stored as a blob and referenced by an entry in the namespace:

{
	"name": "paper.pdf",
	"pdf_hash": "blake3-hash-of-pdf",
	"text_hash": "blake3-hash-of-extracted-text",
	"tags": ["research", "climate"],
	"created_at": "2024-01-15T10:30:00Z"
}

Content-Addressed Storage

All file content (PDFs, extracted text) is stored in iroh-blobs using content-addressing:

• Files are identified by their BLAKE3 hash
• Duplicate files are automatically deduplicated
• Content can be verified for integrity

Embedding Sync

Embeddings are stored in iroh-docs under embeddings/{doc_id}/{model_id}. This design:

• Avoids redundant computation — generating embeddings is expensive, so peers share them
• Preserves model flexibility — different peers can use different embedding models
• Enables offline use — embeddings sync with documents, ready for immediate use

When a peer receives a document, it checks for existing embeddings matching its configured model. If found, they’re used directly. If not (different model or new document), embeddings are generated locally and stored for other peers to use.

Data Flow

Local Import

1. User adds PDF to collection
2. Extract text via lopdf
3. Store PDF blob → get pdf_hash
4. Store text blob → get text_hash
5. Create metadata entry in iroh-docs
6. Index text + generate embeddings in milli

On Sync

When a new metadata entry arrives from a peer:

1. Fetch text blob using text_hash
2. Index text + generate embeddings in milli
3. PDF blob fetched on-demand (when user opens document)

What Syncs vs What’s Local

Local Storage

~/.local/share/insight/
├── iroh/               # iroh data (blobs, docs)
└── search/             # milli index

~/.cache/huggingface/hub/
└── models--*/          # Downloaded models (LLM + embedding)

On Windows, app data is under %LOCALAPPDATA%\insight\ and models under %USERPROFILE%\.cache\huggingface\hub\.

Development

Prerequisites

• Rust (stable)
• Node.js 20+
• pnpm
• Platform-specific dependencies (see below)

Linux

sudo apt-get install libwebkit2gtk-4.1-dev libappindicator3-dev librsvg2-dev patchelf

macOS

Xcode Command Line Tools:

xcode-select --install

Windows

Visual Studio Build Tools with C++ workload.

Running Locally

# Install frontend dependencies
pnpm install

# Start development mode
pnpm tauri dev

Building

# Development build
pnpm tauri build --debug

# Release build
pnpm tauri build

GPU Acceleration

# NVIDIA (CUDA)
cd src-tauri && cargo build --release --features "cuda flash-attn cudnn"

# Apple Silicon (Metal)
cd src-tauri && cargo build --release --features metal

Testing

Backend (Rust)

cd src-tauri && cargo test

Frontend (Svelte)

pnpm test        # Watch mode
pnpm test:run    # Single run (CI)

Project Structure

insight/
├── src/                 # Svelte frontend
├── src-tauri/          # Tauri + Rust backend
│   └── src/
│       ├── commands/   # Tauri commands (IPC)
│       └── ...
├── crates/
│   └── insight-core/   # Core library
└── docs/               # This documentation

Understanding Dependencies

Prefer local tools over web searches:

# Generate and browse docs for exact dependency versions
cargo doc --open

# View dependency graph
cargo tree

# Source code at
~/.cargo/registry/src/