Tars for Obsidian: tag-triggered AI text generation inside your notes

The problem Tars solves is context switching, not model access

Access to a language model is not the scarce thing. Access to the paragraph you were just thinking about is. Tars is built around that gap: instead of copying text into a chat window and pasting the answer back, you write in the note and let a tag mark the point where generation should happen. The README describes the flow as selecting an assistant tag, for example #Claude :, from the command list, or typing # followed by the tag and a space to trigger completion. The plugin is aimed at Obsidian users who keep long-form notes, drafts or research files and want the model's reply stored in the same document, in the same order, as the rest of the writing. It supports desktop and mobile, and the repository's package.json lists Handlebars and Axios as the only runtime dependencies, which is a small footprint for a plugin that speaks to roughly a dozen providers.

Paragraphs, blank lines and callouts define what gets sent

The unit of work is the paragraph at the cursor or inside the selection. A paragraph in this plugin's terms is either several lines of plain text not separated by empty lines, or a code block. Messages must be separated by blank lines, and the README states plainly that a paragraph cannot contain multiple messages. The conversation follows the usual ordering: a system message first and optional, then user and assistant messages alternating. Anything inside a callout is ignored and never sent, which gives you a place to keep private notes alongside a prompt without leaking them to the provider. A #NewChat tag starts a fresh conversation, which matters because the plugin otherwise reads the surrounding message sequence as history. The status bar reports character count, rounds and elapsed time while a request runs, so you can see how much text left your vault without opening the developer console.

Installing Tars and running a first exchange

The README does not spell out a manual installation procedure, and the repository has no published release artifacts described in the README, so the practical path is the Obsidian community plugin browser or the project's GitHub repository. Once enabled, open the settings page, add an AI assistant, set the API key and configure the model. The README's own example is the smallest possible exchange: a user line, a blank line, then an assistant tag.

#User : 1+1=?（user message）
(blank line)
#Claude :（trigger）

After you type the assistant tag and a space, the plugin sends the preceding paragraph. You should see the reply written into the note below the tag. If your provider is not in the picker, or its model list cannot be read, the README says to set an override under "Override input parameters" as JSON, which takes precedence over the picker:

{"model":"your-desired-model"}

The README also notes that when the model list cannot be fetched at all, for instance on an account still awaiting verification or behind a relay that does not implement the endpoint, the row becomes a plain text field and you type the model name directly. To retry a bad answer, select the response and trigger the assistant tag again; the documentation states that this deletes the previous response and generates a new one.

Provider coverage is wide, and uneven by design

The README lists Azure OpenAI, Claude, DeepSeek, Doubao, Gemini, Kimi, LongCat, MiniMax, Ollama, OpenAI, OpenRouter, Qianfan, Qwen, SiliconFlow, X.ai Grok and Zhipu. The differences are not cosmetic. With Azure, the model field holds the deployment name chosen in the portal rather than a model id, which trips up people who copy an identifier from the model catalogue. DeepSeek, LongCat, MiniMax and Zhipu render reasoning output in callout format, so chain-of-thought arrives as a collapsible block instead of inline prose. Doubao supports a bot API and, according to the README, DeepSeek's web search plugin and knowledge base plugin. Zhipu adds a web search option. Ollama is the local option, and the package.json carries the ollama client as a dev dependency, which is consistent with local inference being a first-class path rather than an afterthought. There is no single behaviour you can assume across all of them.

Where Tars gets in the way

The model picker is the sharpest edge. Most providers are asked for their own model list, so the choices come from the API rather than from a list baked into the plugin, and a model the provider no longer advertises will not appear. That is good hygiene and bad for reproducibility: a note written against a specific model last year may not be reproducible today if the provider retired it. The override field is the escape hatch, but it is JSON typed by hand, and a malformed object fails quietly from the writer's point of view. Multimodal input has a harder boundary. The README warns that only embedded files such as ![[example.jpg]] are supported and that external URL links will not work, so a note that references an image by URL will not analyse it. Callouts being excluded from the payload is sensible for privacy but surprising if you drafted your prompt inside one. And because messages are delimited by blank lines, a paragraph that contains one is silently split, which changes what the model sees.

Tars against Smart Connections, Copilot and Cline

The related searches around this plugin point at Smart Connections, Copilot and Cline, and the three differ from Tars in ways that decide the choice. Smart Connections is built around embeddings and semantic retrieval across the vault, so its job is surfacing related notes rather than generating a reply at the cursor; if your problem is finding, it is aimed at that problem and Tars is not. Copilot is a chat-oriented Obsidian plugin with its own model configuration, including Ollama and OpenRouter; it keeps a conversation surface, whereas Tars writes into the document as ordinary Markdown that you can edit, diff and export. Cline is an agentic coding assistant for the editor, not a note-generation tool, and its unit of work is a task with tool calls rather than a paragraph. Tars also exports conversations to JSONL for ms-swift fine-tuning, which none of the retrieval or chat plugins describe. The honest summary is that Tars is the narrowest of the group: one paragraph in, one reply out, in place.

Licence, maintenance and the cost of upgrading

The repository is MIT licensed, which permits commercial and private use, modification and redistribution provided the copyright notice and permission notice are retained. Nothing in the repository suggests a separate licence for the plugin's prompt templates or documentation images under docs/, so treat those as covered by the same MIT terms unless the repository says otherwise; this is a description of the licence text, not legal advice. On maintenance, the last push was on 2026-08-28 and the most recent release is 3.6.0 from the same day, with 3.5.3 the day before and 3.5.2 in March 2026. That is a bursty release pattern rather than a steady one, and the gap between 3.5.2 and 3.5.3 is worth remembering when you plan upgrades. Upgrading is cheap mechanically: the repository has a version-bump script wired into npm version, and versions.json tracks the minimum Obsidian version per release, so an Obsidian update is the thing that can force your hand. Building from source uses tsc for type checking and esbuild for bundling, and the plugin ships as main.js.

Editorial conclusion

Adopt Tars if you already write in Obsidian and want replies to land next to the prompt, with each provider's key stored in the plugin settings. Skip it if you need a stable pinned model, since most providers are queried for their own model list and a model they stop advertising disappears from the picker. Before trusting it with real notes, confirm that your provider exposes its model list, that the tag and blank-line syntax survives your existing files, and that a retry deletes the previous answer rather than appending to it.

Frequently asked questions

Official sources

1. Issues
2. License: MIT
3. README
4. Releases
5. TarsLab/obsidian-tars on GitHub