Skip to main content

How It Works / Local & Privacy

Your knowledge, on your terms

Local-first architecture is a design principle, not a compromise. Every conversation, memory, and document is a file on your filesystem. What you route to a cloud provider travels directly from your machine to theirs — Memorandai runs no servers that intercept or hold your data.

Local Architecture

All Memorandai data — conversations, memories, keystones, documents — lives on your filesystem. No cloud sync, no remote servers, no third-party storage. When you route a prompt to a cloud AI provider, it goes directly to that provider under their terms. Memorandai is never in the middle.

You can browse, back up, port, or delete any of it at any time — standard file formats on your filesystem, nothing proprietary in between.

Data Management

The Data screen under Library → Exporters gives you a curated export path on top of the filesystem-level access. Pick what to back up by category — Projects (flow graphs, workspaces), Memories (conversation shards, keystones, ingested documents), Notebooks (pages, domains, embedded images), Settings (API keys, model preferences, feature flags), Profile (identity and AI-generated profile) — and Memorandai writes a single zip you can copy to another machine, save to cloud storage, or hand to a backup tool.

Restore is a drop-target away: drag a previous backup zip into the Restore panel and Memorandai re-hydrates the categories you choose to bring over.

Memorandai's Data Management screen with two panels: an Export panel on the left listing five selectable data categories (Projects, Memories, Notebooks, Settings, Profile) each with file counts and a checkbox, ending in an 'Export Selected' button; and a Restore panel on the right with a drag-and-drop zone for uploading a backup zip.

No proprietary container, no vendor lock-in. The export is a standard zip of the same files you could move manually — Data Management is just the convenient shortcut.

Bring Your Own Keys

Use your own API keys from OpenAI, Anthropic, Google, and xAI. You pay the providers directly at their published rates. Memorandai never sees your keys, never adds markup, and encrypts them at rest.

Memorandai's API Providers settings screen showing four provider cards in a 2-by-2 grid (OpenAI, Anthropic, Google, xAI), each with the provider's active model name (gpt-5.5, claude-opus-4-7-1m, gemini-3.1-pro-preview, grok-3), the canvas features it powers (chat nodes plus the relevant image-generation provider), a 'Get your API key' link, a masked key preview, and Change/Remove/Test Connection controls. Above the grid: a Quick Setup row with three preset cards (Best Quality, Balanced, Budget) for auto-configuring all providers at once. A 'Usage & Cost' link sits in the top right; the page header reads '4 of 4 providers configured.'

Built-In Local Inference

Download and run local GGUF models in a few clicks — GPU-accelerated when available, CPU-friendly otherwise. Free for local-only conversations and useful for sessions you'd rather keep entirely on-device. Memorandai works best with cloud providers configured for the full feature set; local inference is a complement, not a complete replacement.

  • Configurable tool access on models that support it
  • No internet required for local-only conversations after initial model downloads
  • Same canvas workflow as cloud models — local nodes slot into the same Flows
  • Curated, rotating recommendations — current slate: Qwen 3.5 (2B / 4B / 9B / 27B), Qwen3-VL 8B (vision), and Gemma 4 E4B — all one-click downloadable in the app
  • Custom download — paste any HuggingFace model URI or direct .gguf URL for models beyond the curated set
Memorandai's Local Models screen with three sections stacked vertically. The Hardware panel at the top shows the detected GPU (NVIDIA GeForce RTX 4090 Laptop GPU running on the Vulkan backend), VRAM totals (15.7 GB total, 5.1 GB used, 10.5 GB free), and the currently active model (Qwen3 8B, 4.7 GB in memory, 37 GPU layers) with an Unload button. The Downloaded Models panel below lists two installed GGUF models with Load/Unload and delete controls per model. The Recommended Models panel at the bottom shows curated download cards for Qwen 3 8B (tagged tool-calling, recommended, and latest) and Llama 3.1 8B Instruct (tagged popular and general), each card showing model size, a one-paragraph description, and a Download button.

Local Model Support

Memorandai supports four cloud chat providers (Anthropic, OpenAI, Google, xAI) and local GGUF inference via node-llama-cpp. As of 0.9.7, local coverage is broad: chat — including the Helios overlay — and most background processing run on a local model once you enable local processing, or set a local model as your Helios / processing model. What stays cloud-leaning is narrower now: tasks that need strict, parseable JSON (fragile on smaller models), true image vision (locally, a model reads image text via on-device OCR, and genuinely sees an image only with a vision-capable model plus the optional vision runtime), and a handful of features bound to a cloud provider by construction. The matrix below names every feature explicitly.

Full Local Support

Chat surfaces and most background tasks run end-to-end on a local model. Chat surfaces use whichever model you select; background tasks route local when local processing is enabled (or the relevant model is itself a local one), and fall back to cloud only on an empty or failed local result.

Feature Notes
Local Chat node (Flows mode) Native llama.cpp via node-llama-cpp v3, GGUF models loaded into VRAM. Tool calling via grammar-constrained generation, capped at 20 user-selected tools.
Chat View (linear chat mode) Shares the same local backend as the canvas; a local model set as Helios is handled by a first-class local branch in the chat stream.
Helios chat (Global overlay + canvas) Set a local model as your Helios (preferred) model and the overlay runs fully on-device: curated tools, image OCR, and the optional vision runtime included. Quality scales with the model and your hardware.
Roundtable (local participant) A loaded local model fans out one-shot alongside cloud participants (no tools).
Reflection node Margin notes in the local model's voice when attached to a local response. Prose, no JSON fragility.
Auto-memo / nightly consolidation Routes local first when local processing is on (auto-loads a model); cloud fallback on error or empty result.
Thread brief generation Tries the loaded local model first, then gpt-4o-mini, then haiku.
Self-notes (Dream Cycle, per-genus) Open-ended prose. With local processing on, every genus is written by the one loaded local model.
Helios convergence self-note Open prose. Runs local when local processing is on, or your Helios model is a local one.
Identity brief generation Long-form prose. Runs local when local processing is on, or your processing model is a local one.
Profile identity-summary First-class local branch with its own model auto-load; selectable per request.
Daily Insight (regular + Helios voice) Routes by the resolved model id. Runs local when your processing model (regular) or Helios model (Helios voice) is a local one; cloud fallback on an empty result.
Keystone miner Local-first via the processing model with lenient JSON parsing; cloud fallback. Also powers the keystone-interview endpoints.
Helios proposal miner Local-first when local processing is on; cloud fallback.
Timeline scan Local-first when local processing is on; also covers document extraction and the timeline interview.
Knowledge distillation Per-cluster topic and summary synthesis runs local-first (clustering already uses local MiniLM vectors); cloud and heuristic fallbacks.
Idea miner Local-first when local processing is on; cloud fallback.

Partial — Cloud Recommended

A local path exists, but with a real caveat: strict-JSON tasks are fragile on smaller models, image vision reads text rather than truly seeing, and one synthesis path still leans on the cloud.

Feature Notes
Image attachments in chat (vision) Reads, doesn't see. A local model extracts the text in an attached image via on-device OCR (offline), labeled honestly as "read the text, did not see the picture." It genuinely sees an image only with a vision-capable model (e.g. Qwen3-VL) plus the one-time vision runtime; otherwise it degrades to OCR, never a fabricated description.
Roundtable synthesis Partly local. The identity-lens ("Helios Perspective") chunk runs on your local Helios model; the structural-summary chunk and the "neutral" synthesis mode still route to a cloud provider.
Helios Keystone Revision Cycle Fragile. Runs local, but needs a parseable JSON disposition array; smaller local models often miss the format and the cycle skips that pass.
Keystone mining (Dream Cycle phase) Fragile. Needs a parseable JSON array of candidates. Journal-derived candidates also pass a fully-local vector corroboration gate.
Memory quality scoring Fragile. Needs a parseable JSON score array; a batch that won't parse is skipped, not fatal.
Archive review scoring Mixed. The heuristic sweep (empty / duplicate detection) is fully local and model-independent; the LLM-scored archive decisions share the strict-JSON fragility above.

Cloud Only

Features bound to a cloud provider by construction: provider-specific chat nodes, image generation, the two agentic code-builders pinned to Claude, and the cloud-key connectivity test.

Feature Why cloud-only
Per-provider chat nodes (Claude, GPT, Gemini, Grok) Each node is bound to its provider by definition.
Image generation (DALL-E 3, GPT Image 2, Imagen 4, Grok) No local image-generation path.
MCP server builder An agentic Anthropic tool-use loop pinned to Claude; requires an Anthropic key.
Custom node builder An agentic Anthropic tool-use loop pinned to Claude; requires an Anthropic key.
Connectivity test Validates a cloud provider's API key and reachability — cloud-only by definition. Local model readiness is shown separately on the Local Models page.

Matrix reflects Memorandai 0.9.7.

MCP Servers

Extend Memorandai with Model Context Protocol servers. Install community servers or build your own. Each server adds new tools that every AI model on your canvas can use. The extensibility layer for power users.

Memorandai's MCP Servers page with an 'Add MCP Server' modal open in the foreground. The modal lets users register a new server with transport type (Command for local stdio or Remote SSE for hosted endpoints), server name, command (e.g. npx), arguments (one per line), optional environment variables, and an optional description. A warning at the bottom reminds users that only servers from trusted sources should be added — the command runs with the user's account permissions and can read or write to local data. Behind the modal: the existing MCP Servers list including a built-in Memory Search server with its available tools (memory-search, quotes-composer, memory-info).

Custom Nodes

Build your own node types with MCP command transport. Define input forms, connect to external services, stream results back to the canvas. Your workflow, your tools.

Memorandai's Custom Node Builder, a three-panel workspace for designing custom canvas nodes through an LLM-assisted spec-and-build flow. Left panel: a list of builder sessions including 'code-security-scanner', 'Test New Node Build', and 'Web Search Results Node', with a 'New Builder Session' button at the top. Center panel: a long Markdown spec for a search-results-display node covering UI features (search query display, clickable URLs, scrollable results, clean typography, error handling), design features (dark-theme color coding, icons, responsive sizing), and technical details (tool mapping, data handling, status management, TypeScript, React Flow); a 'Describe the custom code you want to build' input box sits at the bottom of the center panel. Right panel: a Live Preview pane showing the rendered node mockup (search-results-display with a search input and 'No results found' placeholder), a Mapped Tools section, and a Component Code byte counter.

Encryption & Security

API keys are encrypted at rest using machine-specific keys. No telemetry, no analytics, no tracking. The app does not phone home. Memorandai never sees, stores, or transmits your data — what reaches a cloud model is your call alone.

Offline-Friendly License

Activate once online. After that, your license works offline — no subscription server to check in with, no recurring validation. Local-only chat works fully offline; cloud providers and integrations require Internet and API keys.

Take control of your knowledge

Your data, your keys, your machine. No compromises.

Become a Founding Member