Official Smart Plugins site
Smart Plugins are independent third-party plugins for Obsidian. Smart Connections is the flagship plugin.
Obsidian Copilot comparison
A broad AI assistant, or a note-first workflow around your vault?
Choose Copilot when you want one assistant inside Obsidian for chat, Vault QA, commands, writing, projects, web and media workflows, and agents.
Start with Smart Connections when you want related notes from the note you are already working on before asking an assistant. Use Smart Lookup when the question is the starting point. Use Smart Context when found notes should become reusable AI input. Use Smart Chat Core when the provider thread should stay attached to the note it serves.
The Smart workflow is complete only when the work-owning note improves from a reviewed result, not merely when retrieval, copied context, or model output exists.
This page compares Copilot for Obsidian, not Microsoft Copilot or GitHub Copilot. It focuses on Smart Connections plus the adjacent Smart surfaces that support the same note-first path: Lookup, Context, and Chat Core.
Surface related notes from the note you already have open.
Ask naturally when you remember the idea, not the exact words.
Use native search for exact words, filenames, headings, tags, syntax, or regex.
Copy only the sources the assignment needs before sending them to AI.
Save provider thread links and active/done state in the note they serve.
About this comparison: It is published by Smart Connections and links to official Copilot and Smart documentation for pricing, setup, privacy, local retrieval, context, and saved-thread claims.
Last checked: 2026-05-18. Messaging alignment updated: 2026-05-19.
Copilot and Smart Connections can both belong in an Obsidian vault. The practical question is which one should be your default starting point for the work in front of you.
Using both is valid: Copilot can remain the broad assistant while Smart Connections, Lookup, Context, and Chat help you find sources, carry context, and keep threads tied to notes.
This is not a full Smart Plugins tour. These surfaces cover the common path from “I need the right notes” to “AI used the right context and I can resume the work from the note.”
Current note → Connections
Open a real note, preview one related result, then drag it into the note or open it if it helps. Treat scores as ranking signals, not truth.
Question → Lookup
Use Lookup when you remember the idea but not the phrase, file name, or heading. Expand the top results and confirm relevance before acting.
Reusable set → Context
Start with the note that owns the assignment. Copy Depth 0 first, then expand only when linked support matters or the answer names a real missing source.
Durable thread → Chat Core
Use Smart Chat Core codeblocks when a provider thread should stay linked to the project, meeting, research, decision, or draft note it serves. Core stores thread links and active/done state in Markdown; it does not claim to store the full provider transcript by default.
Smart Loop is a workflow, not another plug-in. The point is to keep the outcome, context, thread or returned result, review, next step, and deliverable in a single note so the work can continue from a better place.
A single note states what done means, what matters, and what context should travel with the assignment.
Send the smallest useful context through your preferred AI path, whether that is a provider chat, Smart Chat, or another model workspace.
Review the result. If it is useful, use it or update the note. If it is generic, improve the outcome, constraints, or context before copying more.
The workflow is not complete when a model produces text. It is complete when the note that owns the outcome matches your current understanding and the work can be delegated again, continued, or shipped from that improved note.
Test the products against the work you actually do. Do not judge either product from screenshots, feature lists, or a blank note.
Copilot is strongest when the assistant is the product center. Smart Connections is strongest when your notes should decide what the assistant sees next.
| Decision point | Obsidian Copilot | Smart Connections, Lookup, Context, and Chat Core |
|---|---|---|
| Product center | The assistant panel and its modes are the main place AI work happens. | The work-owning note stays the system of record; Smart surfaces help retrieve, package, delegate, and resume from that note. |
| Best starting point | Start with the assistant: chat, Vault QA, commands, projects, composer, and agent workflows. | Start with the job: current note → Connections, question → Lookup, reusable set → Context, durable thread → Chat. |
| First useful proof | The assistant produces a useful answer, command result, draft, or workflow output. | A related note is previewed and acted on; copied context is used; the thread or result returns to the note; the note improves from review. |
| Related material | Relevant Notes and Vault QA live inside the assistant experience. | Connections shows related notes and blocks from the active note; Lookup searches by meaning when the question is the anchor. |
| Exact search vs meaning search | Copilot centers assistant search and QA workflows. | Use Lookup for meaning-level questions. Use Obsidian native search for exact words, headings, tags, filenames, syntax, or regex. |
| Context before AI | Context is chosen through assistant modes, selected files/folders, projects, Vault QA, and plan-dependent features. | Smart Context copies the note or sources the assignment needs so you can inspect what travels before pasting or sending it. |
| Thread continuity | Copilot can save chat conversations and custom prompts in configured folders. | Smart Chat Core saves provider thread links and active/done state in Markdown; the saved thread link is something to return to, not the deliverable itself. |
| Setup before retrieval | Copilot Free is BYOK. Free Vault Search is described as powered by the user’s own embedding model via API key. Plus adds built-in model paths. | No API key is needed for Smart Connections Core semantic retrieval. Connections and Lookup use the local retrieval path after indexing. |
| Data boundary to check | Check whether you are using Free BYOK, local model setup, Plus, or self-hosting. Copilot Plus privacy terms describe backend processing for Plus service requests. | Check indexing status, exclusions, local embeddings, copied context, and which provider workflow you explicitly use. |
| Plain recommendation | Use Copilot when you want the broad assistant to be the main AI surface inside Obsidian. | Use Smart Connections when your first problem is finding the right notes, then use Lookup, Context, and Chat Core as the work needs them. |
Copilot Free is BYOK, and its pricing page says Free Vault Search uses the user’s own embedding model via API key. No API key is required for Smart Connections Core semantic retrieval; Smart Connections Core uses zero-setup local embeddings stored on device by default.
Copilot’s pricing page describes a local data store for Vault QA. Smart Environment stores source and embedding data inside a .smart-env/ folder in your vault and exposes source, exclusion, embedding, and status checks.
Smart Context prepares clipboard exports inside Obsidian; copied content can leave Obsidian when you paste it into another AI tool or send it through an enabled provider workflow. Start with the smallest useful context, then expand only when the answer names a real gap.
Smart Chat Core stores provider thread links and active/done state in Markdown. The provider keeps the provider-side conversation; Smart Chat Core does not claim to store the full provider transcript by default.
Copilot Plus privacy terms say Plus prompts and requests may be processed through Copilot backend infrastructure, including when a user supplies their own API key. For either product, check the exact mode, plan, provider, and workflow before sensitive use.
Smart Connections is the best first comparison point because the common Copilot alternative question starts with related notes inside the vault. Lookup, Context, and Chat Core are included because they are the next practical steps: ask by meaning, copy the right context, and keep the thread attached to the note.
It can be a replacement if your main job is finding related notes from the current note. It can also run alongside Copilot if you want Copilot for assistant workflows and Smart tools for finding, reviewing, and carrying note context.
Use Connections when the current note is the anchor. Use Lookup when a question is the anchor. Use Obsidian native search when exact words, filenames, headings, tags, syntax, or regex are the anchor. Use Context when found notes should become AI input. Use Chat Core when the provider thread should stay attached to the note where the work lives.
Smart Loop is a workflow, not another plug-in. Make the outcome clear, delegate with context, review the result, and improve the note that owns the outcome. The loop is not complete at the answer; it closes when the note improves enough to delegate again, continue, or ship.
No API key is required for Smart Connections Core semantic retrieval. API credentials matter only when you choose cloud/API chat, generation, or other remote workflows.
Smart Chat Core stores provider thread links and active/done state in Markdown. It does not claim to store the full provider transcript by default; the provider keeps the provider-side conversation.
Copying context is the product proof. The workflow proof is that the answer uses details from the starting note or names missing context instead of guessing. If the answer is generic, improve the starting note before copying more.
Check the retrieval path, local index status, exclusions, copied context, provider settings, and where the thread or result will live afterward. Avoid assuming any AI workflow is private or local without checking the exact mode you are using.
Copilot is a better fit when you want one broad AI assistant inside Obsidian for chat, Vault QA, commands, writing, projects, web/media features, and agent-style workflows.
Yes. You can keep Copilot for assistant tasks and use Connections or Lookup to recover related notes before deciding what context should go into the assistant.
Open one real note that owns an outcome. Use Copilot for the assistant workflow you would actually run. Use Connections from the current note, Lookup only if a question is the anchor, Context for the smallest useful source set, and Chat Core or your current AI tool for delegation. Compare useful source material found, setup required, data-flow boundary, and whether the note improved from the reviewed result.
