Questions and real answers.

GNO is a local knowledge workspace that indexes your documents — Markdown, PDF, Word, Excel, PowerPoint — and makes them instantly searchable with AI-powered answers. It combines keyword and semantic search to find the right passage, not just the right file. Everything runs on your machine with no cloud dependencies.

Install via Bun with `bun install -g @gmickel/gno`. On macOS, vector search requires Homebrew SQLite (`brew install sqlite3`). Run `gno doctor` to verify your installation, or launch `gno serve` for a guided first-run setup in the browser.

Yes. The current support target is windows-x64. The CLI path works via Bun/global install, and the desktop beta now ships as a packaged Windows zip on GitHub Releases. Windows arm64 is not supported yet.

Yes. After install, run `gno serve` and open localhost:3000. The dashboard walks you through adding a folder, choosing a speed-vs-quality preset, downloading local models if needed, and checking health for indexing, models, and disk.

Yes. Run `gno daemon` for headless continuous indexing — same watch, sync, and embed loop as the Web UI, no browser. For background lifecycle, `gno daemon --detach` self-spawns and exits 0; `gno daemon --status` and `gno daemon --stop` give you first-class control without nohup, launchd, or systemd.

GNO indexes Markdown (.md) with frontmatter extraction, PDF (.pdf), Microsoft Word (.docx), Excel (.xlsx), PowerPoint (.pptx), and plain text files. It also detects document language across 30+ languages.

Not in place. GNO can view and search converted PDF/DOCX/PPTX/XLSX content, but those source files stay read-only. If you want to work on the content, use “Create editable copy” to generate a markdown note with source provenance.

No. GNO is 100% local and privacy-first. All indexing, embedding, search, and AI answers run on your machine. Zero telemetry, zero tracking. Your documents never leave your computer. It works completely offline.

Yes. Point GNO at your Obsidian vault directory and it indexes everything. GNO understands wiki links ([[note]]), frontmatter tags, and can discover semantic connections between notes that Obsidian’s built-in search misses. It adds hybrid search, AI answers, and a knowledge graph on top of your existing vault.

Increasingly, yes, depending on what you need. Obsidian still wins on plugins, Canvas, Excalidraw, and broad note-app customization. GNO now covers search, browse tree navigation, graph exploration, safe editing, AI answers, and agent access. If you care more about retrieval and AI workflows than plugins, GNO is becoming a serious local workspace alternative.

`gno search` is fast keyword matching (instant, ~5–20ms) — great for exact terms. `gno vsearch` uses meaning-based search (~0.5s) — finds documents about a concept even if they don’t contain your exact words. `gno query` combines both and reranks results for the best answer (~2–3s default, ~0.7s fast mode).

Use `gno ask "your question" --answer`. This searches your documents using the hybrid pipeline and generates a cited answer using a local LLM. No cloud APIs needed.

Yes — use `--collection` or `-c`, for example `gno search "term" -c notes`. You can also filter by tags (`--tags-any`, `--tags-all`), dates (`--since`, `--until`), and exclude specific documents (`--exclude`).

GNO supports multi-line query documents using `term:` (exact keywords), `intent:` (semantic intent steering), and `hyde:` (hypothetical document passages). These give you explicit control over the retrieval pipeline for complex queries.

On macOS and Linux the default is `~/.config/gno/config/index.yml`. On Windows it lives under `%APPDATA%\gno\config\index.yml`. Run `gno doctor` to see the exact resolved paths for your machine.

Use `gno collection add path --name name` for each folder, then run `gno update` to index them all. You can add Obsidian vaults, project docs, research folders, and code repos — any directory on your machine.

Use `gno serve` when you want the browser dashboard, REST API, or desktop shell integration. Use `gno daemon` when you only want headless continuous indexing. Both share the same `--detach` / `--status` / `--stop` lifecycle flags, so the choice is about UI vs headless — not about backgrounding. Avoid running both against the same index at the same time.

Yes — add them to the `exclude` array in your collection config (for example `node_modules`, `.git`, temporary files). You can also use `--exclude` at query time to skip specific documents from results.

GNO uses local models via node-llama-cpp. The default preset is slim-tuned (~1GB) with the fine-tuned local expansion model plus the same embed, rerank, and answer stack as slim. Other built-in presets are slim, balanced (~2GB), and quality (~2.5GB).

No. GNO runs entirely locally with no API keys or cloud services required. Models are downloaded once and run on your machine.

Use `gno models use <preset>` then `gno models pull` to download, or switch presets directly in the Web UI. GNO validates cached GGUF files before loading them and reports intercepted/non-model downloads clearly. Presets are slim-tuned, slim, balanced, or quality. You can also offload inference to a remote GPU server on your network via HTTP backends.

Yes. GNO supports per-collection model overrides. Add `models.embed` under one collection in `index.yml`, set it in the Web UI collection model dialog, or use `gno collection add --embed-model` when creating a new collection. This is the recommended way to tune code collections without changing the rest of the workspace.

Yes. GNO accepts Hugging Face URIs (`hf:org/repo/file.gguf`), local file URIs (`file:/path/to/model.gguf`), and remote OpenAI-compatible HTTP endpoints (`http://host:port/path#modelname`). Use them in a custom preset globally or as per-collection overrides.

Yes — that’s a supported pattern. Run GNO on one machine, run an OpenAI-compatible server (Ollama, LM Studio, vLLM) on another machine on your LAN, and point GNO at it with HTTP model URIs. Works for embed, answer, and expansion roles.

Re-embed so vector and hybrid search catch up to the new model. Run `gno embed` for everything or `gno embed <collection>` for one collection. You can then optionally run `gno collection clear-embeddings <collection>` to remove stale old-model vectors.

GNO publishes a fine-tuned retrieval model (`gno-expansion-slim-retrieval-v1`) on Hugging Face, trained locally on Apple Silicon with MLX LoRA. It achieves nDCG@10 of 0.925 and Ask Recall@5 of 0.875. Install it with `gno models use slim-tuned`.

Run `gno skill install --scope user` and your coding agent can search your documents on demand. Works with Claude Code, Codex, OpenClaw, and more. Your agent only pulls in what it needs — no bloated prompts.

Yes — that’s one of the strongest use cases. Install the skill and Claude Code can look up your notes, docs, and project files whenever it needs context. Much better than pasting notes into the chat manually, because it only pulls in the relevant passages.

Run `gno mcp install --target cursor` (or zed, windsurf, amp, etc.). This lets your editor’s AI assistant search and retrieve from your documents directly — no copy-paste needed.

Model Context Protocol (MCP) is an open standard that lets AI assistants use external tools. GNO provides an MCP server so Claude Desktop, Cursor, Zed, Windsurf, and other AI tools can search your documents as if they had your entire knowledge base available.

Yes. GNO indexes your documents — Markdown, PDFs, Office files, text — and lets you search and ask questions with AI-powered answers, all running locally. Use it from the workspace UI, the command line, the API, or directly from your AI tools.

Yes — use `--json` for machine-readable output, for example `gno search "term" --json | jq`. GNO also supports CSV, Markdown, XML, and URI output formats. For TypeScript apps, use the SDK to embed GNO directly.

gno.sh is a hosted publication layer. Export a note or collection from local GNO with `gno publish export <target>`, then upload that artifact at /studio to get a reading-first public URL, secret link, invite-only space, or encrypted share. The publish surface is one feature in the broader GNO product — see the publish platform page for details.

GNO connects to Claude Cowork as an MCP server, giving it a persistent, searchable knowledge base across all your documents. Without GNO, Cowork can only read files in the specific folders you connect to a session. With GNO, Cowork can search your entire document collection, get ranked results, and cite sources — making it dramatically more useful for research, analysis, and knowledge work.

Yes — GNO is the natural companion for an LLM Wiki. The LLM Wiki pattern has your AI compile raw sources into a persistent markdown knowledge base. GNO indexes that wiki and provides hybrid search, AI answers, and tool integration on top. Point GNO at your wiki folder and every agent — Claude Code, Cowork, Cursor — can query the compiled knowledge instantly. GNO also indexes the raw sources themselves, so you get retrieval across both layers.

GNO is a local RAG system — but with a real workspace around it. Unlike cloud RAG services that require uploading your data, GNO runs entirely on your machine. It combines keyword search, semantic search, and reranking into one retrieval pipeline, adds AI answers with citations, and integrates with your existing AI tools. For personal knowledge, team research, or business context, it’s a complete local alternative to hosted RAG platforms.