Smart Chat codeblocks

Smart Chat Notes lets you embed web-based chat UIs (ChatGPT, Claude, Gemini, Grok, Perplexity, Deepseek, AI Studio) directly inside the note they belong to.

The core shift:
your chat threads stop being “lost in browser tabs” and become trackable artifacts inside your vault.
You can bookmark threads per note, return later, and mark them done when the loop is closed.

If you want to send large, curated vault context to a thread from the exact note it belongs to, pair this with Smart Context Builder:
Smart Context Builder

What this solves

If any of these are true, this feature will feel immediately useful:

“I have great AI outputs, but I cannot find the thread later.”
“My project knowledge is in Obsidian, but my AI conversations live elsewhere.”
“I open 10 tabs per project and lose track of what I was waiting on.”
“I ask something that takes time, then forget to come back for the result.”
“I want to keep AI work next to the work it references.”

This is not about replacing your chat provider.
It is about organizing and operationalizing your threads inside your notes.

Mental model: chat threads are tasks

A thread is a unit of work.

If you are waiting on it: keep it bookmarked in the relevant note.
When it is resolved: click Mark done.
Your note becomes a lightweight “async inbox” for the project.

This is how you get the “asynchronous” upside without losing control.

Two-minute quickstart

Open the note where the work actually lives (project hub, decision note, draft, bug report, meeting note).
Insert a Smart Chat Notes codeblock for your provider.
In Reading View, use the embedded UI to open an existing thread or start a new one.
Save/bookmark the thread URL into the codeblock (so it is pinned to this note).
When you are done (or you are ready to stop tracking it), click Mark done.

Tip

You do not need a “perfect system” first.
Start by embedding one thread in one important note.
The habit is the product: always pin the thread to the note it is about.

What the embedded controls mean

Across providers, the embedded UI adds a small control layer so the note stays in charge:

Thread URL list: saved/bookmarked threads for this note
Mark done: closes the loop on the currently tracked thread
Refresh: reload the embed if the provider UI gets stuck
Open in browser: jump out to a full tab when you need it
Copy link: grab the current thread URL
Grow: expand the embed for comfortable reading/writing

Your markdown remains the source of truth: the note stores thread links (and status), not the provider UI.

Supported platforms (annotated)

Below are examples of the same workflow across different providers.

Green: saved thread URLs inside the codeblock
Magenta: Mark done
Orange: size/visibility controls (ex. Grow)
Cyan: utility controls (refresh/open/copy)

ChatGPT

Claude

Grok

Gemini

Perplexity

Deepseek

AI Studio

Desktop vs mobile

These embeds rely on Obsidian desktop (Electron) webview support.
On mobile (iOS/Android), the codeblock will not render the embedded web UI the same way.

If you are curious about the technical reason and current status, see:
https://github.com/brianpetro/smart-chatgpt-obsidian/issues/7#issuecomment-3505152432

Practical takeaway:

Desktop: full embedded chat UI + controls
Mobile: treat the codeblock as a thread bookmark list (still useful for continuity)

Next steps

Add one embedded chat codeblock to your highest-value project hub note.
Create a Chat Inbox dashboard note with dataview.
If you routinely reuse context, build your first named context pack:
Smart Context Builder

If you want the broader Smart Chat story (and how this relates to Pro capabilities), start here:
https://smartconnections.app/smart-chat/

And if you are deciding between Core and Pro:
https://smartconnections.app/pro-plugins/