Skip to content
Smart Plugins

Official Smart Plugins site

Smart Plugins are independent third-party plugins for Obsidian. Smart Connections is the flagship plugin.

Getting Started with Smart Chat

Smart Chat keeps chat threads attached to the notes they belong to.

Start here when you want to use a Smart Chat codeblock inside an Obsidian note, open a chat thread from that note, save the thread link in Markdown, and come back later without hunting through browser tabs.

First useful result

Add one Smart Chat codeblock to one real note and confirm one chat thread is saved to the note.

What you will do

  1. Open the note where the chat thread belongs.
  2. Insert one Smart Chat codeblock.
  3. Start or open one chat thread.
  4. See notification confirm the thread is saved.

The goal is not to build a perfect system.

The goal is one useful thread that stays attached to the note it serves.

Before you start

You need:

Smart Chat Core uses provider web UIs through codeblocks.

You do not need API model configuration for this first workflow.

Tip

You can still use local models in Core with the Open WebUI codeblock if you already run Open WebUI locally.

1. Open the note where the chat thread belongs

Start from the note that owns the work.

Good candidates:

The simple rule:

Put the chat thread in the note where future-you would look for it.

2. Insert a Smart Chat codeblock

Use the command palette to insert the codeblock for the chat provider you want to use.

Minimal ChatGPT example:

```smart-chatgpt
```

Supported codeblocks:

Provider Codeblock
ChatGPT smart-chatgpt
Claude smart-claude
Gemini smart-gemini
Grok smart-grok
Perplexity smart-perplexity
DeepSeek smart-deepseek
AI Studio smart-aistudio
Open WebUI smart-openwebui
Kimi smart-kimi

3. Start or open a chat thread

Switch to Reading view and use the embedded chat UI.

You can:

Watch Smart Chat attach AI work to the note

Callum introduces Smart Chat as the point where chat can live inside Obsidian while staying attached to the project note it serves.

4. Confirm the thread link was saved

When the chat provider creates a real thread URL, Smart Chat saves the link into the codeblock.

Example:

```smart-chatgpt
chat-active:: 1767302492 https://chatgpt.com/c/6956e559-8060-8329-8150-7167e477c05a
```

You know it worked when:

The note contains a chat thread link or state you can reopen later.

Smart Chat Core stores thread links and active/done state in Markdown.

It does not store the full provider transcript by default.

5. Mark active or done after review

Use active/done state when the chat thread needs follow-up tracking.

State Meaning Use it when
chat-active:: The thread is still relevant, waiting, or in progress. You need to return later.
chat-done:: You reviewed the thread and closed the loop for now. The useful output has been handled, promoted, saved, or dismissed.

Done does not mean Smart Chat judged the answer correct.

Done means you reviewed the thread and decided the conversation is closed for now.

What gets saved

A Smart Chat codeblock can hold multiple thread links.

Example:

```smart-chatgpt
chat-active:: 1767302492 https://chatgpt.com/c/6956e559-8060-8329-8150-7167e477c05a
chat-done:: 1767132305 https://chatgpt.com/c/69544c91-0c78-832e-8e49-d21049a33e51
```

This makes the note a lightweight thread home.

The thread remains available in the note. No searching through browser tabs, searching history, or relying on memory.

Desktop vs mobile

Platform What to expect Best use
Obsidian Desktop Embedded chat UI, thread controls, save URL, mark active/done Full Smart Chat codeblock workflow
Obsidian Mobile Codeblock remains useful as a thread bookmark list; embedded web UI does not render the same way Continuity and recovery of saved threads
Any text editor Chat threads are still recoverable because the URL lives in the note File-over-app continuity

On mobile, treat Smart Chat codeblocks as a lightweight thread index attached to the note.

The continuity value still matters because the saved links live in Markdown.

Optional: add context before sending

Smart Chat Core keeps the thread attached to the note.

It does not automatically make the answer grounded.

When the chat needs source material, build or copy the smallest useful context before sending it into the thread.

Good next step:

Smart Context Builder

Optional: build a Chat Inbox

After a few notes contain chat-active:: or chat-done:: lines, create a Chat Inbox with Dataview.

A Chat Inbox helps you see open delegated chat work across your vault.

Use it when:

Start here:

Build a Chat Inbox with Dataview

When to use Smart Chat API Extension

Use Smart Chat Core codeblocks when the job is:

Use Smart Chat API Extension when API model configuration is needed inside Obsidian.

That includes workflows where you want Smart Chat to use configured local or cloud API models through the Smart Environment model setup.

Start here:

Use Smart Chat API Extension

First useful result checklist

Before moving on, check:

Check You know it worked when...
Note chosen The codeblock is in the note where the chat thread belongs.
Codeblock added The note contains one Smart Chat codeblock.
Thread started or opened The embedded chat shows a real thread or selected saved thread.
Link or state saved The codeblock contains chat-active::, chat-done::, or a saved thread link.
Review path clear You know whether the thread should remain active or be marked done.
Next step clear You know whether to add context, build a Chat Inbox, or use the Pro API Extension page for API model configuration.

Related pages