Guides

Fully local setup

Sigil is air-gappable by construction. There is no Sigil cloud to talk to, no telemetry, and no account. The only egress comes from the LLM and embedding providers you choose — so choose local ones.

The all-local stack

StorageBuilt-in PGlite at ~/.sigil/db, or a Postgres on your own network

LLMOllama — classification, extraction, AUDM decisions, synthesis

EmbeddingsOllama — mxbai-embed-large, 1024 dimensions

EgressNone

Setup

Install Ollama and pull two models.
Terminal window
```
ollama pull qwen2.5:7b          # the LLM
ollama pull mxbai-embed-large   # the embedder — 1024-dim, matches Sigil's fixed dimension
```
Any instruct model that reliably emits JSON works for the LLM. Sigil’s calls are extraction, classification, and structured decisions, not open-ended chat — a 7B model is genuinely enough.

Install Sigil.

curl -fsSL https://raw.githubusercontent.com/Anmol-Srv/sigil/master/install.sh | sh

In the wizard, choose:
- Database → Built-in (or your own Postgres)
- LLM → Ollama, host http://localhost:11434
- Embeddings → Ollama, model mxbai-embed-large
Both are live-tested before they’re saved.
Verify.
Terminal window
```
sigil doctor
```

The embedding dimension is fixed

Every embedding Sigil stores is exactly 1024 dimensions. The database’s vector(N) columns and every provider are pinned to it, so the two can never drift into the dimension-mismatch failure that breaks ingest and search with an unhelpful error.

A model that can’t natively emit 1024 dimensions — or truncate to it, Matryoshka-style — is rejected at setup rather than failing later. mxbai-embed-large is native 1024 and is the default.

Quality trade-offs

Local is meaningfully worse than a frontier model at two specific jobs, and roughly equivalent at the rest.

Task	Local impact
Fact extraction	Slightly noisier — more supplementary facts, occasionally a merged one
AUDM decisions	Weaker at spotting that two differently-worded facts mean the same thing, so more near-duplicates
Classification	Fine. It’s a small labelling task.
Query routing	Fine
Embeddings	`mxbai-embed-large` is competitive; retrieval quality holds up well
Synthesis	Noticeably weaker prose

If duplicates accumulate, lower memory.skipThreshold slightly in Settings → Advanced so more candidates are treated as the same fact.

A middle path: local embeddings, remote LLM

The privacy calculus isn’t all-or-nothing. Embeddings see every chunk of every document you ingest; the LLM sees a chunk at a time during extraction. Keeping embeddings local and using a hosted LLM cuts the majority of the exposure:

Embeddings → Ollama
LLM → OpenRouter / OpenAI / Anthropic / your Claude Code subscription

Sigil’s provider detection supports this directly — the two are configured independently.

Per-task model routing

If you do use a hosted LLM, you can send different work to different models — a cheap one for the high-volume per-chunk extraction, a smarter one for AUDM decisions:

llm.extractionModel   = openrouter:qwen/qwen3.5-flash
llm.decisionModel     = openrouter:anthropic/claude-sonnet-latest
llm.entityModel       = (provider default)
search.synthesizeModel = openrouter:anthropic/claude-sonnet-latest

Set these in Settings → Advanced. See Configuration.

Performance

Local generation is slower than an API call, and it shows up where you’d expect:

Search is unaffected — it’s a database query. Still ~33ms.
Hot context is unaffected — the snapshot is pre-rendered.
Capture is slower. The Stop hook runs classification and extraction, so a turn’s save takes seconds rather than under one. It’s asynchronous, so it doesn’t block you.
Ingest is much slower. A large document is minutes.

Raise ingest.workerConcurrency if your machine has headroom. It needs a daemon restart.

Confirming nothing leaves

sigil doctor

Both provider lines should read ollama. Beyond that, Sigil makes no other outbound calls except the periodic update check against GitHub — which you can switch off:

preferences.noUpdateCheck = true

Settings → General → Skip update checks.