Guides by Editorial Team

How to Use a Local LLM With Obsidian, Joplin, Logseq, and Notion

Plug a local Ollama model into Obsidian, Joplin, Logseq, or Notion so notes never leave your machine. Plugins that work, ones that do not, and what each costs.

A personal note vault is among the more intimate documents a knowledge worker keeps. Therapy journaling, half-written novel chapters, board-meeting prep, a partner’s medical history pasted in for a question, a customer’s private matter that an LLM could summarise before a call. The hosting model for the app that holds the notes matters: a hosted AI assistant gets the same access the user does, and the difference between “the notes leave the machine when the assistant runs” and “the notes never leave the machine” is the question that decides which app and which plugin to pick.

This page walks through what “local LLM inside a notes app” actually looks like in October 2026 across the four apps a local-first user is most likely to be considering: Obsidian, Joplin, Logseq, and Notion. The short version: three of the four have working open-source paths to a local model; the fourth (Notion AI) is a hosted-only feature and a local-first setup should plan around that fact rather than expect a workaround.

TL;DR

  • The four apps split into two camps on local AI. Obsidian, Joplin, and Logseq are local-first markdown vaults: notes are files on disk, and open-source plugins can talk to a local Ollama server. Notion is a hosted workspace, and Notion AI is a hosted AI feature with no self-hosted variant.
  • Obsidian has the deepest plugin ecosystem. Local GPT (MIT) handles chat, selected-text rewriting, RAG over linked notes and PDFs, and an Ollama provider out of the box. Smart Connections handles semantic search with a local embedding model by default. Copilot adds agent mode, Quick Ask, and BYOK routing to local models.
  • Joplin has at least two viable local paths. joplin-plugin-jarvis (AGPL-3.0) supports Ollama and Hugging Face providers, plus chat-with-notes, semantic search, autocomplete, and literature-review generation. The official plugin directory also lists NoteLLM, whose README covers Ollama through its OpenAI-compatible API.
  • Logseq has a small but functional plugin. ollama-logseq (MIT) adds commands for Ask AI (with and without page or block context), Summarize Page, Summarize Block, Create a flash card, and Divide a todo task into subtasks, plus a /ollama slash command, all routed through the local Ollama server.
  • Notion AI has no local-model option. Notion AI is a built-in workspace feature with Notion Agent, Custom Agents, and AI Meeting Notes, all processed by Notion’s AI subprocessors. The product page states “Notion AI will not use your data to train our models unless you opt in to a request to share your data.” The closest thing to a local path is the reverse direction: Notion MCP lets an external MCP client, which can be one backed by a local model, read the workspace, but the notes themselves still live on Notion’s servers.
  • The recurring setup is the same for all three local-first apps. Install Ollama, pull a chat model and an embedding model (the standard recipe is one of the Qwen3 or Gemma 3 tags for chat and nomic-embed-text for embeddings), point the plugin at http://localhost:11434, and pick the model from the plugin’s refresh list.

The two architectural camps

A notes app either owns the file or rents the file. The distinction determines what a “local LLM” can mean.

Local-first markdown vaults (Obsidian, Joplin, Logseq): notes are plain-text Markdown files in a folder the user controls. The app reads them, indexes them, and renders them; nothing leaves the machine unless the user opts into a sync or a plugin that makes a network call. A local LLM sits inside that boundary: the plugin sends selected text or a chunk of the vault to the Ollama server running on localhost, the model returns an answer, and the round trip stays on the device. The Obsidian pricing page lists the core app as “Free without limits” - the sync and publish services are optional paid add-ons.

Hosted workspaces (Notion): notes are rows in a database the vendor owns. The user has a session, the app has the file. Any AI feature in this camp runs on the vendor’s servers and processes the notes in the vendor’s account; there is no file on the user’s disk to point a local model at. The Notion pricing page lists Free, Plus from $10 per member per month, Business from $20 per member per month (USD), and Enterprise through sales; Notion AI is bundled into Business and Enterprise with a limited trial on Free and Plus.

The choice of app is therefore also the choice of where the AI runs. The next three sections cover the local-first apps and their plugins; the fourth covers Notion.

Obsidian: three plugins that get it done

Obsidian’s plugin model is the most permissive of the four apps. The community plugin store lists dozens of AI plugins; three cover most of what a non-technical reader wants from a local AI inside their notes.

Local GPT (pfrankov/obsidian-local-gpt, MIT). Per the project page, it integrates AI assistant capabilities directly into Obsidian: select text, open a context menu or Action Palette, apply an AI action. Features include image support, RAG using links, backlinks, and PDFs, customisable community actions, and reasoning and creativity modes. Providers include local Ollama and OpenAI-compatible endpoints, configured through the companion “AI Providers” plugin. The README’s RAG recipe is to pull an embedding model alongside the chat model: nomic-embed-text for English (fastest) or bge-m3 for multilingual accuracy.

Smart Connections (brianpetro/obsidian-smart-connections, source-available “Smart Plugins License”). The plugin’s tagline is “Find related notes and excerpts while writing.” The default embedding model runs locally with no API key; broader LLM provider support has moved into the separate Smart Chat Pro plugin. The Connections view shows notes semantically related to the current note and updates as the user switches files; Lookup view runs ad-hoc semantic search across the vault; “Send to Smart Context” copies a selection’s related context for AI use. Embeddings are created locally and notes stay on the user’s machine. For a broader walk-through of local RAG over a personal document set - same embedding model recipe, same Ollama server - our AnythingLLM + Ollama guide covers the same setup outside the Obsidian plugin layer.

Copilot (logancyang/obsidian-copilot, AGPL-3.0). The plugin ships Quick Chat, Quick Ask (ask about a selection without leaving the note), Agent mode for multi-step work that can create files, Projects for ongoing work with custom instructions, and Skills (Markdown, Bases, Canvas, CLI). Provider support covers Copilot-hosted models (paid licence), BYOK for cloud, local, or OpenAI-compatible providers, and routing through Claude Code, Codex, or opencode. The open-source frontend is AGPL-3.0; the backend services for hosted features are proprietary.

Common setup. Install Ollama, pull a chat model (ollama pull qwen3:8b is a 5.2 GB download, a tight but workable fit on an 8 GB machine), pull nomic-embed-text for any plugin that needs embeddings, leave the Ollama server running, and point the plugin’s provider setting at http://localhost:11434. The model then appears in the plugin’s refresh list.

Joplin: one plugin that does most of it

Joplin is an open-source note app that stores Markdown notes in a local SQLite database rather than as loose files, syncs through Joplin Cloud, a self-hosted server, or other targets, and runs on desktop and mobile. The community plugin directory carries several AI plugins.

Jarvis (alondmnt/joplin-plugin-jarvis, AGPL-3.0) is the most full-featured. Per the project page, the name stands for “Joplin Assistant Running a Very Intelligent System”, and it works with online and offline models (OpenAI, Hugging Face, Gemini, Universal Sentence Encoder); the project’s setup guide documents Ollama for both offline chat and offline embeddings. Features include a chat sidebar with three modes (Chat, Note, Collection), chat-with-notes that uses personal notes as context, related-notes semantic search (local by default), annotation (titles, summaries, links, tags), literature review generation via Semantic Scholar, Crossref, Elsevier, Springer, and Wikipedia, text editing for selected text with natural-language instructions, and autocomplete at the cursor.

The plugin can be installed from Joplin’s marketplace or from GitHub releases; API keys are needed for OpenAI, Google AI, or Hugging Face depending on the models chosen, but not for the Ollama path. Jarvis takes full endpoint URLs rather than a bare host: the guide’s Ollama examples are http://127.0.0.1:11434/v1/chat/completions for chat and http://127.0.0.1:11434/api/embed for embeddings. Mobile support is listed on the project page, which matters for anyone who wants the same workflow on a phone.

Other options. The Joplin plugin directory also lists NoteLLM, a community plugin whose README covers any local LLM server compatible with the OpenAI API, including Ollama (base URL in the form http://host:port/v1). The same README notes that Ollama can fail on Joplin mobile because of CORS restrictions. A lighter plugin fits better for a notes workflow that just needs chat with a vault, while Jarvis is the right pick for the literature-review and autocomplete features.

Logseq: small plugin, covers the basics

Logseq is an outliner-first local-first note app that stores notes as Markdown or Org-mode files in a folder and a local database. Its plugin directory is smaller than Obsidian’s; one plugin covers most of the common asks.

ollama-logseq (omagdy7/ollama-logseq, MIT) is the standard choice. Per the project page, the plugin adds commands for Ask AI (free-form prompt, with page context, or with block context), Summarize Page, Summarize Block, Create a flash card, and Divide a todo task into subtasks. The plugin also exposes a context-menu entry, a /ollama slash command, a toolbar button, and configurable settings for host, model, and shortcuts. Like the Obsidian and Joplin paths, the setup is Ollama on localhost:11434 and a chat model of the user’s choice.

Notion: hosted AI only, no local path

Notion is a hosted workspace: notes, databases, and projects live in Notion’s account. The product page lists the AI features: Notion Agent (multi-step tasks using workspace context), Custom Agents (recurring team work), Enterprise Search (cross-app search over connected Slack, Google Drive, GitHub), AI Meeting Notes, Research Mode, and AI writing blocks. The page’s privacy language states:

“Notion AI will not use your data to train our models unless you opt in to a request to share your data.”

The same page lists contractual agreements with AI subprocessors that prohibit training on customer data, SOC 2 Type 2 and ISO 27001 certifications, GDPR and CCPA compliance, TLS 1.2+ encryption in transit, zero data retention for Enterprise, and 30-day retention otherwise, and HIPAA compliance for Enterprise via zero-retention APIs.

The practical implication: there is no self-hosted variant of Notion AI and no first-party plugin model that would let a user point Notion AI at a local Ollama server. Notion does publish Notion MCP, described in its developer docs as “a remote MCP server hosted by Notion”, which an external MCP client can use after OAuth to read and update workspace content; a client backed by a local model can therefore process Notion pages on the user’s machine, but the pages are still stored and served by Notion. A local-first reader who needs AI over Notion content has three honest options: accept the hosted processing and rely on Notion’s contractual and policy commitments, run a local model through an MCP client against a workspace that still lives on Notion’s servers, or move the notes to an app that supports a fully local path (Obsidian, Joplin, or Logseq) and keep Notion for the things that need a shared hosted workspace. The pricing page’s structure - Notion AI capabilities included as a limited trial on Free and Plus and bundled into Business and Enterprise - makes clear that Notion AI is positioned as a paid hosted feature rather than a swappable backend.

What the local-first stack looks like end-to-end

For anyone who wants the shortest recipe, the cross-app shared setup is:

  1. Install Ollama on the laptop. It runs as a local server on port 11434.
  2. Pull a chat model that fits the hardware. On 8 GB of RAM, the qwen3:8b tag (5.2 GB download, 40K context) is a sensible starting point. On 16 GB, qwen3:14b (9.3 GB) or gemma3:12b (8.2 GB, 128K context, Gemma Terms). On 24 GB, mistral-small3.1:24b (15 GB, Apache 2.0, 128K context).
  3. Pull an embedding model for the plugins that need one. nomic-embed-text on Ollama is the common choice for English; check the plugin’s own README for the model name it expects.
  4. Install the notes app and the plugin. The Obsidian, Joplin, and Logseq setup instructions linked above cover the install steps.
  5. Point the plugin at http://localhost:11434, refresh the model list, pick the chat model and the embedding model, and start a chat or ask about a selection.

The notes never leave the machine because the app reads them, the plugin reads them, the Ollama server reads them, and nothing in that chain has a network destination.

What a local AI inside a notes app does not solve

Three honest caveats, all surfaced inside the plugins themselves.

  1. Quality on small hardware is uneven. A 4B-8B local model will miss some reasoning and paraphrase work that a frontier hosted model handles. Plugin authors tend to ship suggested-model lists but do not provide proofreading benchmarks; quality claims in the READMEs are general expectations, not measurements.
  2. Long-vault search is bounded by the embedding model and the plugin’s RAG implementation. Smart Connections’s embedding-based Lookup, Local GPT’s RAG over linked notes and PDFs, and Jarvis’s related-notes semantic search all chunk or summarise the vault differently. A query about a paragraph written five years ago may or may not return; chunking and context windows still apply.
  3. Sync changes the calculation. A local-first vault that syncs through a vendor service is no longer strictly local. Obsidian’s Sync add-on costs $4 per user per month on the annual plan and is end-to-end encrypted, which preserves a strong privacy property; syncing through iCloud, Dropbox, or any unencrypted cloud reverses it. The local LLM runs locally regardless, but the notes’ resting state is no longer “files on a single disk.” A separate self-hosted Ollama + Open WebUI setup is the broader pattern when the goal is a ChatGPT-like assistant with the same local-only guarantee for general documents.

A short decision framework

Five questions, in order:

  1. Are the notes allowed to leave the machine? If no, the answer is one of the local-first apps and a local Ollama model; the choice between Obsidian, Joplin, and Logseq is about which workflow fits the reader (linked Markdown vault, cross-platform sync, outliner).
  2. Do the notes need to live in a shared hosted workspace? If yes, Notion is the path and the AI is hosted; a setup that needs both a shared workspace and a local LLM has to keep them separate.
  3. What is the primary AI job? Chat with the vault (Local GPT, Copilot, Jarvis), semantic related-notes (Smart Connections, Jarvis’s related notes), or quick summarise-and-extract (ollama-logseq, Jarvis’s summarise). The plugins overlap; the right primary fit depends on which job the reader opens the app for.
  4. How much VRAM or RAM is available? 8 GB gets a 4B-8B chat model with limited context; 16 GB gets a 12B-14B model and more usable context; 24 GB or more lets a 24B-27B model run with longer context. The plugins do not enforce these limits; Ollama and the model tag do.
  5. Is mobile part of the workflow? Joplin’s Jarvis plugin lists mobile support. Obsidian and Logseq plugins are desktop-first; mobile Obsidian can reach an Ollama server on the same network, but the experience is best on desktop.

For an Obsidian-based setup, the practical default is Ollama on the laptop, Qwen3 14B (or Gemma 3 12B if the Gemma Terms of Use are acceptable), the Obsidian Local GPT plugin plus Smart Connections for semantic search, and notes that never leave the disk. Joplin with Jarvis is the right choice if mobile matters more than the vault’s graph view. Logseq with ollama-logseq is the right choice if the primary task is summarising daily-journal entries and flash cards. Notion AI is the right choice only when hosted processing is acceptable in exchange for a shared workspace.

Sources