Smart Chat

Use provider-attached threads, local or API models, and native thread management from one Smart Chat reference. Core and Pro capabilities are documented together, with Pro requirements labeled where they apply.

In this guide

Embed and organize AI chat threads in Obsidian

Smart Chat codeblocks keep provider conversations attached to the note they serve. The note stores readable thread references and active or done state, while desktop can render the provider interface directly inside Obsidian.

Availability and supported environments

Provider-specific codeblocks support the documented web chat providers. Smart Chat Pro also provides the universal smart-chat block. Full embedded provider interfaces require Obsidian desktop; mobile preserves saved thread references through the no-webview fallback.

Supported providers

The same note-attached thread workflow is available across the supported provider codeblocks.

Provider-specific codeblocks support:

Codeblock	Provider
`smart-chatgpt`	ChatGPT, including recognized Codex and Sora links
`smart-claude`	Claude
`smart-gemini`	Gemini
`smart-grok`	Grok
`smart-perplexity`	Perplexity
`smart-deepseek`	DeepSeek
`smart-aistudio`	Google AI Studio
`smart-openwebui`	Open WebUI
`smart-kimi`	Kimi

Smart Chat Pro also provides the universal smart-chat codeblock for supported providers in one block.

Insert a Smart Chat codeblock

Open the Command Palette and search for the provider name or Smart Chat codeblock action.

Run the insert action from the note that should own the thread. Provider-specific actions insert the matching fence; Pro can also insert the universal smart-chat fence.

Provider-specific and universal blocks

A provider-specific fence keeps one provider identity in the codeblock language. The universal Pro block stores the provider with each thread reference.

Use a provider-specific block for one provider. Use the universal block when one note may track threads from several supported providers.

Can one note track several providers?

Yes. Use several provider-specific blocks or the universal Pro smart-chat block.

Thread storage grammar

Saved state remains readable Markdown:

chat-active:: <unix_seconds> <thread_url>
chat-done:: <unix_seconds> <thread_url>

chat-active:: means the thread still needs attention.
chat-done:: means the thread is complete for now.
The timestamp supports recency displays and Dataview queries.
The provider URL remains the durable thread reference.
Text after a valid URL can remain as an annotation.

Select a saved thread

When a block contains several saved threads, use the selector to choose which record the block displays.

The selector shows the provider and active/done state where supported. Selecting a thread does not remove or reorder the Markdown records.

Start a new provider chat

A new provider session remains unsaved until the provider exposes a durable thread URL.

The New chat menu starts an unsaved provider session.

A provider page is saved only after Smart Chat recognizes a durable thread URL. Home pages, temporary routes, and unsupported routes cannot be captured automatically.

Why was a new chat not saved automatically?

The provider has not navigated to a recognized durable thread URL, or the route is unsupported.

Mark done and Mark active

Mark done changes the note-owned thread state while leaving the provider conversation intact.

Use Mark done when the selected thread no longer needs attention.

The Markdown field changes from chat-active:: to chat-done::.
The provider conversation is not deleted or archived.
Mark active changes the field back to chat-active::.
Repeating the current state does not create a duplicate update.

Does marking a thread done change the provider conversation?

No. It changes only the Markdown tracking state in the note.

Build context

Build context opens or reuses thread-specific Smart Context when the integration is available.

Review the selected notes or files before copying or sending that context to the provider.

Open, copy, and refresh

Open in browser opens the selected provider thread outside the embed.
Copy link copies its saved thread URL.
Refresh reloads the current embedded provider page.

These controls do not change active/done state.

Grow and contain

Grow expands the embedded provider surface. Contain returns it to the normal note-width presentation.

This is a display setting; it does not change the thread record.

Build a thread dashboard with Dataview

Because state is stored as inline fields, Dataview can list active and completed thread bookmarks.

```dataview
LIST WITHOUT ID file.link
WHERE chat-active
SORT file.mtime DESC
```

```dataview
LIST WITHOUT ID file.link
WHERE chat-done
SORT file.mtime DESC
```

These queries read note-owned provider bookmarks. They do not list Smart Chat API Extension thread records.

Provider sign-in and browser data

Some providers complete sign-in more reliably through Obsidian Web Viewer.

Sign in through Web Viewer.
Return to the codeblock.
Select Refresh.

For repeated human-verification loops, clear Web Viewer browser data only after confirming that the sign-in can be recreated. Google AI Studio may require saving the conversation before a durable URL exists.

Desktop and mobile behavior

Desktop uses Electron webview support for the full embedded provider interface.

On mobile, saved thread URLs remain useful as bookmarks or external links, but the full provider embed and automatic URL capture are unavailable.

Universal Smart Chat codeblock behavior (Pro)

The universal Pro block adds shared provider selection, stable block identity, managed provider surfaces, and cross-provider controls.

`smart-chat` codeblock

Smart Chat Pro adds one universal codeblock for supported provider threads.

```smart-chat
chat-id:: 002a41caaf2a4be9
chat-active:: 1767302492 https://chatgpt.com/c/example
chat-done:: 1767132305 https://claude.ai/chat/example
```

`chat-id::`

chat-id:: <id> gives the rendered block a stable identity. Smart Chat adds it during desktop initialization when it is missing. Do not copy the same ID into another block.

`chat-active::`

chat-active:: <unix_seconds> <thread_reference> tracks a saved thread that still needs attention. Text after the thread reference is preserved as a trailing annotation.

`chat-done::`

chat-done:: <unix_seconds> <thread_reference> tracks a completed thread. Marking a thread done changes only the note's tracking state; it does not archive or delete the provider conversation.

Does marking done change the provider conversation?

No. It changes only the Markdown tracking state.

Supported provider types

The universal block supports ChatGPT, Claude, Gemini, AI Studio, DeepSeek, Perplexity, Grok, Kimi, and configured Open WebUI instances. Saved unknown HTTP links can still be opened as generic links, but Smart Chat cannot automatically recognize their new-thread URLs.

New chat menu

Choose a provider from New chat to open an unsaved session. The thread is added to Markdown only after the provider navigates to a recognized durable thread URL.

Why was a new chat not saved?

The provider did not navigate to a recognized durable thread URL, or the page could not be captured.

Saved thread selector

The selector shows saved active and done threads with provider and recency information. When the saved list is large, done threads move into a separate submenu so active work remains easier to reach.

Thread actions

Available actions depend on the selected provider and thread state:

Mark done or Mark active
Open in browser
Copy link
Refresh
Build context
Append clipboard to input on providers that expose that action

Embedded provider surface

A saved provider thread keeps one managed embedded surface per thread and workspace document. When the same thread is already displayed elsewhere, use Show here to move the active surface instead of loading a duplicate session.

Why does the same thread say it is shown elsewhere?

One embedded provider surface is reused for that thread. Choose Show here to move it to the current block.

Web Viewer user-agent

The codeblock menu can copy the user-agent setting from Obsidian Web Viewer to the embedded provider surface. Use it only when a provider requires the same browser identity for sign-in or compatibility.

Obsidian hotkeys inside the provider surface

Supported configured Obsidian modifier hotkeys can pass through the embedded provider page. Editing keys and provider send behavior remain protected so typing in the chat input is not hijacked.

Mobile and no-webview fallback

When embedded webviews are unavailable, the codeblock renders a static bookmark list:

saved web threads open externally
native smart-chat: references display as labels
new-chat capture, automatic URL saving, state actions, and embedded input automation are unavailable

Troubleshooting Smart Chat codeblocks

A new chat is saved only after the provider creates a recognized durable thread URL.
Use Refresh and Obsidian Web Viewer sign-in when a provider page stalls.
Confirm the selected Markdown record when the wrong thread appears.
Static links on mobile are expected.
Repair duplicate or missing chat-id:: values before another unsafe block update.

Chat with Obsidian notes using local and API models

Smart Chat provides a native Obsidian thread workspace for configured local and cloud chat models. Each completion can carry a reviewable Smart Context and retain the model metadata used for the request.

The native Smart Chat workspace keeps the active thread, context actions, composer, and current model status visible in one surface.

Availability and model requirements

This workflow requires Smart Chat Pro and at least one compatible chat-completion model configured through Smart Environment. Provider credentials, local model servers, and media support remain specific to the selected model path.

Open Smart Chat

The Smart Chat command opens the native thread workspace from a standard Obsidian entry point.

Open Smart Chat from its ribbon action, Command Palette entry, or assigned hotkey.

The view reopens the saved active thread when possible. If that record is unavailable, it opens the latest non-deleted thread or creates a new one.

Confirm or change the chat model

The thread status bar shows the configured chat model.

Choosing a model changes the default for future responses.
Each completed response keeps the model and provider used for that request.
A missing or unavailable model blocks sending until model configuration is repaired.

Does changing the status-bar model change an earlier response?

No. It changes the default for later responses. Completed responses retain the model metadata from their own request.

Use the thread toolbar

The toolbar can:

start a new thread
open Thread History
open Smart Chat settings
open help
rename the current thread

A changed thread name is saved when the field is committed with Enter or loses focus.

Write and send a message

The composer accepts normal text and large pasted input.

Type @ to open context selection for the current response.
The send shortcut follows the configured modifier-key setting.
A failed request leaves the current message available for correction and retry.
Missing model configuration produces a visible error rather than a successful-looking response.

Add known notes as context

Add context opens Smart Context for the current response.

Each response keeps its own reviewed context set. A new empty response can inherit the previous completed response's context so the conversation can continue without rebuilding the same set.

Find context with Lookup

Lookup can retrieve candidate notes and add the reviewed results to the current completion context.

Lookup context uses the current question to retrieve likely notes or blocks.

Review the proposed sources and remove weak, stale, or unrelated items before sending. Lookup proposes context; it does not make the sources authoritative.

Drag notes and supported files into a thread

Drag supported Obsidian notes or files into the active thread to add them to the current response context.

If a dropped item does not appear in the context tree, add it through Add context or verify that the file type is supported.

Send intentionally without context

The no-context confirmation makes a context-free request an explicit choice.

When no context is attached, Smart Chat can offer:

Lookup context
Select context
Continue without context
Cancel

Continue without context only when a general, ungrounded conversation is intentional.

Why did Smart Chat warn before sending?

The current response had no attached context. Choose Lookup, select known sources, continue intentionally without context, or cancel.

Include or exclude prior messages

Message-level controls determine which earlier exchanges participate in later requests.

Exclude an earlier exchange when it should not influence later responses.

The exchange remains visible in the saved thread. Exclusion changes only the prior-message history sent with future requests.

Custom instructions

Smart Chat supports default instructions and instructions saved for one thread.

Thread instructions take precedence in that thread. Saving the change updates the thread record.

Thread History

Thread History is the fast thread opener. It searches saved thread suggestions and displayed preview text.

The default History surface does not search every word in every message.

Can Thread History search every word in every message?

No. The default History surface searches thread suggestions and displayed previews, not complete message bodies.

Thread Manager

Use Thread Manager for deliberate maintenance:

search by thread name or key
open a thread
rename inline
delete one thread after confirmation
delete selected visible threads after confirmation

Thread data, persistence, and sync

Provider codeblocks store thread URLs in Markdown. Smart Chat API Extension stores its conversations separately under Smart Environment data.

Relevant records can include:

.smart-env/chat_threads/
.smart-env/smart_completions/
.smart-env/smart_contexts/

Syncing .smart-env is not the recommended default unless the chosen sync method has been tested for concurrent writes and conflict recovery. Markdown codeblock links continue to sync like normal note content.

Are API threads the same as provider codeblock bookmarks?

No. Provider codeblocks store URLs and active/done fields in Markdown. API Extension threads use Smart Environment records.

Review context before sending

Review source names, blocks, origin badges, and size estimates in the current Smart Context tree. A new completion can inherit prior context, so remove stale items before sending.

Review completed responses

A completed response shows recorded model information, included context, the user message, and the assistant response. Include or exclude controls affect future history; they do not rewrite completed output.

Recover from model and completion errors

Confirm the model and provider, verify credentials or the local server, remove unsupported media, retry after correcting the cause, or switch to another configured model.

Manage Smart Chat threads in Obsidian

Smart Chat stores native model-backed conversations as thread records. Thread Manager provides the complete management surface; Chat History provides a faster selector for opening a known recent thread.

Thread Manager provides one searchable surface for opening, renaming, reviewing, and deleting saved Smart Chat threads.

Open Thread Manager

Open Chat Thread Manager from the Command Palette.

Thread Manager lists Smart Chat API Extension threads. It does not list provider URLs stored only in Markdown codeblocks.

Is Thread Manager the same as a Dataview Chat Inbox?

No. Thread Manager manages Smart Chat API Extension records. A Chat Inbox lists chat-active and chat-done fields stored in notes.

Search and filter

Search filters visible rows by thread name or key. Hidden rows are not changed or deleted.

Open a thread

Use Open to load the selected thread in Smart Chat. Open uncertain threads before renaming or deleting them.

Rename a thread inline

Rename happens inline in the row.

Enter rename mode.
Change the name.
Save or cancel.

A saved name remains attached to that thread record.

Can I rename a thread without opening it?

Yes. Rename is inline in the manager row.

Delete one thread

Single-thread deletion requires inline confirmation.

This removes the Smart Chat API Extension thread record. It does not remove provider-thread URLs stored in Markdown codeblocks.

Select and delete visible threads

Bulk delete applies only to rows that are both visible and selected.

Filter to a narrow working set.
Select the intended rows.
Confirm the bulk action inline.
Review the remaining list.

Does bulk delete remove every thread matching the search?

No. It removes only selected visible rows after confirmation.

Review thread and message counts

The manager shows thread and completion totals for the current list. Counts support review; they do not indicate that a thread is safe to delete.

Confirmation and refresh states

Delete confirmation stays inside the manager and beside the affected row or selection. This makes the destructive scope visible before the action runs.

Use Chat History

Chat History provides a faster fuzzy selector for reopening a known thread.

Chat History is optimized for opening a saved thread from the active Smart Chat workspace. Thread Manager owns complete search, rename, counts, and confirmed cleanup.

Open History

Open Chat History from the active thread toolbar.

The default History surface lists saved, non-deleted threads.

Thread suggestions

Each suggestion identifies a saved thread and can include its name plus a recent user-message preview.

Completion search

The default History surface does not search every completion or every word in saved messages.

Open the selected thread

Press Enter on a suggestion to open that thread in Smart Chat.

Delete from History

Use Mod+Enter on a highlighted thread to begin deletion. Confirm the action before the thread record is removed.

What does Mod+Enter do in History?

It begins the confirmed deletion flow for the highlighted thread.

Search limitations

Search is designed for fast thread retrieval by the information shown in suggestions. Use Thread Manager for deliberate record maintenance.

Why can I find a thread by name but not by a phrase from the middle of the conversation?

History does not perform exhaustive full-message search.

Chat History vs Thread Manager

Use Chat History to open a saved thread quickly. Use Thread Manager to filter names or keys, rename records, inspect counts, and perform confirmed cleanup. Neither surface is exhaustive full-message search unless the shipping build explicitly enables completion suggestions.

Troubleshooting thread management

Clear the filter and refresh when a thread is missing.
Finish inline Save before expecting a rename to persist.
Current search is limited to documented thread fields and displayed previews.
Review visible selected rows again after filtering.
Open an uncertain thread instead of deleting it based only on age.