fegger
c2c2d51da5
This commit adds support for multi-turn tool calling by making processToolCalls
recursive. Previously, follow-up LLM responses that included additional tool
calls would drop those calls and present the text response instead.
Key changes:
- processToolCalls now accepts a depth parameter (default 0)
- Recurses when follow-up responses contain more tool_calls, up to MAX_TOOL_CALL_DEPTH
- Adds MAX_TOOL_CALL_DEPTH constant set to 5 to prevent infinite loops
- Clears pending actions only after processing is complete or before recursing
- Fixes new-chat container flex layout in styles.css to wrap and start from left
I need to write a clean git commit message for this diff. Let me analyze what changed:
1. In `main.js` and `src/chat-view.ts`:
- `processToolCalls` now has a `depth` parameter with default `0`
- Added `MAX_TOOL_CALL_DEPTH = 5` constant
- Added depth check at start of `processToolCalls`
- When follow-up LLM calls return more tool calls, it now recursively calls `processToolCalls` instead of ignoring
them
- `clearPendingActions()` moved around to be called at appropriate times
- Some variable renames from `finalResponse` to `followUpContent` for clarity
2. In `styles.css`:
- `.ollama-new-chat-container` changed from `justify-content: flex-end` to `flex-wrap: wrap; justify-content:
flex-start`
The main feature is recursive/multi-turn tool calling with a depth limit. The CSS change seems like a minor UI fix
included in the same commit.
Subject line ideas:
- "Add recursive tool call handling with depth limit" (47 chars) - good
- "Support multi-turn tool calls with depth limit" (46 chars) - good
- "Add recursive tool calls and depth limit" (41 chars) - good
- "Implement recursive tool calling with depth limit" (47 chars) - good
Wait, I also need to mention the CSS change? It's minor but part of the commit. However, usually the subject should
capture the main change. If there are multiple unrelated changes, sometimes people mention them, but here the CSS change
seems minor enough that it could be in the body or omitted if not important. Actually looking at the diff, the CSS
change is just adjusting flex properties. It might be related to UI changes needed for the tool call flow, or it could
be an unrelated fix piggybacking.
Actually, the prompt says "write a short clear commit message that summarizes the changes." If I can express it in the
subject line, don't include body. But this seems like a significant enough change that a body might help explain the
"why" and key details.
Let me think about the body. The key points:
- Makes `processToolCalls` recursive to handle follow-up tool calls
- Adds `MAX_TOOL_CALL_DEPTH` (5) to prevent infinite recursion
- Previously, follow-up responses containing tool_calls would drop them
- Also fixes new-chat container layout
Subject: Add recursive tool call handling with depth limit (47 chars)
Body:
Support multi-turn tool calling by recursing in processToolCalls when
follow-up LLM responses contain additional tool_calls. Previously these
were ignored and the text response was shown instead.
Add MAX_TOOL_CALL_DEPTH constant set to 5 to prevent infinite loops.
Clear pending actions at the appropriate recursion boundaries.
Fix new-chat container flex layout to wrap and align left.
Wait, I should check if "Add recursive tool call handling with depth limit" is clear enough. Yes.
Let me count chars:
"Add recursive tool call handling with depth limit"
A-d-d- -r-e-c-u-r-s-i-v-e- -t-o-o-l- -c-a-l-l- -h-a-n-d-l-i-n-g- -w-i-t-h- -d-e-p-t-h- -l-i-m-i-t
3+1+9+1+4+1+4+1+9+1+4+1+5+1+5 = let's just count: "Add" (3) + " " (1) + "recursive" (9) + " " (1) + "tool" (4) + " " (1)
+ "call" (4) + " " (1) + "handling" (8) + " " (1) + "with" (4) + " " (1) + "depth" (5) + " " (1) + "limit" (5) =
3+1+9+1+4+1+4+1+8+1+4+1+5+1+5 = 48 chars. Good.
Actually, looking more carefully at the code:
- The depth check is added
- Recursion is added
- clearPendingActions is moved
- The CSS change is there
Is the body useful? Yes, it explains the behavioral change and why. But maybe I can keep it shorter.
Actually, looking at the instructions again: "If you can accurately express the change in just the subject line, don't
include anything in the message body."
Hmm. This is a fairly complex change. But the subject line "Add recursive tool call handling with depth limit" does
accurately express the main change. The CSS change is minor. However, there are enough details (the depth limit of 5,
the recursion aspect, the fact that it handles follow-up tool calls) that a brief body might be useful to someone
looking at the commit log.
But the instructions also say "Only use the body when it is providing *useful* information" and "Don't repeat
information from the subject line in the message body."
If I use the subject line I proposed, what useful info could the body add?
- The depth limit value (5)
- That it affects follow-up LLM responses
- The CSS fix
Actually, I think a body is appropriate here because the change is not entirely captured by just knowing it's
"recursive" - the fact that it previously dropped tool calls on follow-up is useful context (the "why").
Let me draft:
Add recursive tool call handling with depth limit
When follow-up LLM responses contain additional tool_calls, recurse in
processToolCalls instead of ignoring them. Add MAX_TOOL_CALL_DEPTH
constant set to 5 to prevent infinite loops. Move clearPendingActions
to appropriate recursion boundaries. Fix new-chat container flex layout
to wrap and align left.
Wait, I should check line wrapping. Max 72 chars.
Line 1: "Add recursive tool call handling with depth limit"
Line 2: (blank)
Line 3: "When follow-up LLM responses contain additional tool_calls, recurse in"
Line 4: "processToolCalls instead of ignoring them. Add MAX_TOOL_CALL_DEPTH"
Line 5: "constant set to 5 to prevent infinite loops. Move clearPendingActions"
Line 6: "to appropriate recursion boundaries. Fix new-chat container flex layout"
Line 7: "to wrap and align left."
Let me check lengths:
Line 3: "When follow-up LLM responses contain additional tool_calls, recurse in" = 70 chars. Good.
Line 4: "processToolCalls instead of ignoring them. Add MAX_TOOL_CALL_DEPTH" = 67 chars. Good.
Line 5: "constant set to 5 to prevent infinite loops. Move clearPendingActions" = 69 chars. Good.
Line 6: "to appropriate recursion boundaries. Fix new-chat container flex layout" = 69 chars. Good.
Line 7: "to wrap and align left." = 23 chars. Good.
Actually, should I mention processToolCalls specifically? It's a detail but useful.
Alternative body:
Support multi-turn tool calling by recursing when follow-up responses
contain additional tool_calls. Previously these were discarded and the
text response was shown instead. Add MAX_TOOL_CALL_DEPTH constant set
to 5. Also fix new-chat container flex layout.
Length check:
"Support multi-turn tool calling by recursing when follow-up responses" = 67
"contain additional tool_calls. Previously these were discarded and the" = 70
"text response was shown instead. Add MAX_TOOL_CALL_DEPTH constant set" = 69
"to 5. Also fix new-chat container flex layout." = 46
I think this is clearer. But does it repeat the subject? The subject says "Add recursive tool call handling" and the
body says "Support multi-turn tool calling by recursing..." - that's similar but explains the mechanism, not repeating
per se.
Actually, I could also make the subject slightly different to be more specific:
"Add multi-turn tool call recursion with depth limit"
Then body:
When follow-up LLM responses contain additional tool_calls, recurse in
processToolCalls rather than discarding them. Add MAX_TOOL_CALL_DEPTH
constant set to 5. Move clearPendingActions to correct boundaries.
Also fix new-chat container flex layout.
Hmm. "Add multi-turn tool call recursion with depth limit" is 49 chars. Good.
Actually, looking at the diff again, the most important thing is that `processToolCalls` now recurses. Let me make sure
I capture that.
Another option: The commit could be split conceptually, but since it's one diff, we summarize all changes.
Final decision:
Subject: Add recursive tool call handling with depth limit
Body:
When follow-up LLM responses contain additional tool_calls, recurse in
processToolCalls instead of ignoring them. Add MAX_TOOL_CALL_DEPTH
constant set to 5 to prevent infinite loops. Move clearPendingActions
to appropriate recursion boundaries. Fix new-chat container flex layout
to wrap and align left.
Wait, I want to make sure I don't exceed 72 chars per line in the body.
Line 1: When follow-up LLM responses contain additional tool_calls, recurse in
Count: W(1)h(2)e(3)n(4) (5)f(6)o(7)l(8)l(9)o(10)w(11)-(12)u(13)p(14) (15)L(16)L(17)M(18)
(19)r(20)e(21)s(22)p(23)o(24)n(25)s(26)e(27)s(28) (29)c(30)o(31)n(32)t(33)a(34)i(35)n(36)
(37)a(38)d(39)d(40)i(41)t(42)i(43)o(44)n(45)a(46)l(47) (48)t(49)o(50)o(51)l(52)_(53)c(54)a(55)l(56)l(57)s(58),(59)
(60)r(61)e(62)c(63)u(64)r(65)s(66)e(67) (68)i(69)n(70) = 70 chars. OK.
Line 2: processToolCalls instead of ignoring them. Add MAX_TOOL_CALL_DEPTH
p(1)r(2)o(3)c(4)e(5)s(6)s(7)T(8)o(9)o(10)l(11)C(12)a(13)l(14)l(15)s(16) (17)i(18)n(19)s(20)t(21)e(22)a(23)d(24)
(25)o(26)f(27) (28)i(29)g(30)n(31)o(32)r(33)i(34)n(35)g(36) (37)t(38)h(39)e(40)m(41).(42) (43)A(44)d(45)d(46)
(47)M(48)A(49)X(50)_(51)T(52)O(53)O(54)L(55)_(56)C(57)A(58)L(59)L(60)_(61)D(62)E(63)P(64)T(65)H(66) = 66 chars. OK.
Line 3: constant set to 5 to prevent infinite loops. Move clearPendingActions
c(1)o(2)n(3)s(4)t(5)a(6)n(7)t(8) (9)s(10)e(11)t(12) (13)t(14)o(15) (16)5(17) (18)t(19)o(20)
(21)p(22)r(23)e(24)v(25)e(26)n(27)t(28) (29)i(30)n(31)f(32)i(33)n(34)i(35)t(36)e(37) (38)l(39)o(40)o(41)p(42)s(43).(44)
(45)M(46)o(47)v(48)e(49)
(50)c(51)l(52)e(53)a(54)r(55)P(56)e(57)n(58)d(59)i(60)n(61)g(62)A(63)c(64)t(65)i(66)o(67)n(68)s(69) = 69 chars. OK.
Line 4: to appropriate recursion boundaries. Fix new-chat container flex layout
t(1)o(2) (3)a(4)p(5)p(6)r(7)o(8)p(9)r(10)i(11)a(12)t(13)e(14) (15)r(16)e(17)c(18)u(19)r(20)s(21)i(22)o(23)n(24)
(25)b(26)o(27)u(28)n(29)d(30)a(31)r(32)i(33)e(34)s(35).(36) (37)F(38)i(39)x(40)
(41)n(42)e(43)w(44)-(45)c(46)h(47)a(48)t(49) (50)c(51)o(52)n(53)t(54)a(55)i(56)n(57)e(58)r(59) (60)f(61)l(62)e(63)x(64)
(65)l(66)a(67)y(68)o(69)u(70)t(71) = 71 chars. OK.
Line 5: to wrap and align left.
t(1)o(2) (3)w(4)r(5)a(6)p(7) (8)a(9)n(10)d(11) (12)a(13)l(14)i(15)g(16)n(17) (18)l(19)e(20)f(21)t(22).(23) = 23 chars.
OK.
This looks good. But I should double check: does the body provide useful info not in the subject? Yes, it explains the
specific behavior change (recursing instead of ignoring), the constant name and value, and the CSS fix.
Actually, should I include the CSS fix in the body? It's part of the diff. If I omit it, the
Obsidian Ollama Plugin
A plugin that integrates Ollama with Obsidian, allowing you to chat with local AI models, search your vault context, and use AI tools like creating files.
Features
- Chat with Ollama models directly in Obsidian with streaming responses
- Vault context search — the assistant can reference your notes via semantic (RAG) or keyword search
- Agent Modes — selectable chat modes (Ask, Edit, Organize, Research, Workflow) that change available tools, system prompts, and preview behaviour
- Tool integration — create, read, search, append, edit, rename, move, delete notes, and insert wiki-links
- Structured Memory — persist conversation summaries, user preferences, and learned facts across sessions
- Tool Telemetry — track which tools were called, which notes were searched, and LLM token usage
- Semantic/RAG vault indexing — automatically index your vault into a vector database for intelligent retrieval
- Semantic response cache — repeated or similar queries are answered instantly without hitting the model
- Workflow Engine — execute multi-step AI workflows via
/workflowcommands - Auto-Organizer — AI-powered auto-tagging and auto-linking with dry-run preview and folder scoping
- Obsidian MetadataCache integration — frontmatter, tags, links, and headings are read via Obsidian's built-in cache instead of raw regex parsing
- Customisable model, URL, cache, and memory settings
Prerequisites
- Install Ollama: Follow the instructions at ollama.ai
- Start Ollama:
ollama serve - Pull a chat model:
ollama pull llama3(or any other model you prefer)
Optional — Vault Semantic Index (RAG)
The vault semantic index automatically indexes your Obsidian notes into a local ChromaDB vector database. When you ask a question, the plugin performs semantic search against your notes and includes the most relevant passages as context for the AI.
- Install ChromaDB:
pip install chromadb - Start ChromaDB:
chroma run --host localhost --port 8000 - Pull an embedding model:
ollama pull nomic-embed-text - Enable the vault semantic index in the plugin settings and configure the ChromaDB URL.
Optional — Semantic Cache
The semantic cache stores responses in a local ChromaDB vector database. When you ask a question that is semantically similar to one already cached, the stored answer is returned immediately instead of calling the model.
- Install ChromaDB:
pip install chromadb - Start ChromaDB:
chroma run --host localhost --port 8000 - Pull an embedding model (used to generate vectors for cache lookups):
ollama pull nomic-embed-text - Enable the cache in the plugin settings and configure the ChromaDB URL.
Installation
Quick install (recommended)
Use the included install script. It handles dependency installation, building, and copying the plugin into your vault:
# Clone or download this repository, then run:
./install.sh /path/to/your/obsidian/vault
The script will:
- Install npm dependencies (excluding Ollama — you install that separately)
- Compile the TypeScript plugin
- Copy the built plugin into
<vault>/.obsidian/plugins/ollama-plugin/
Manual install
If you prefer to install manually:
npm install
npm run build
Then copy the plugin into your vault:
mkdir -p /path/to/vault/.obsidian/plugins/ollama-plugin
cp manifest.json /path/to/vault/.obsidian/plugins/ollama-plugin/
cp main.js /path/to/vault/.obsidian/plugins/ollama-plugin/
cp styles.css /path/to/vault/.obsidian/plugins/ollama-plugin/
# Remove old dist/ from previous installs (no longer needed with bundling)
rm -rf /path/to/vault/.obsidian/plugins/ollama-plugin/dist
Note: The plugin is now bundled into a single
main.jsvia esbuild. Theobsidiannpm package is a dev-only type stub — Obsidian provides its own API at runtime. Thechromadbclient library is also bundled intomain.js, so no extranode_modulescopy is needed for the semantic cache feature.
After installation
- Restart Obsidian (or reload:
Ctrl+Shift+P→ "Reload app without saving") - Go to Settings → Community plugins → enable Ollama Plugin
- Configure the plugin at Settings → Ollama Settings
Configuration
Open Settings → Ollama Settings to configure the plugin.
| Setting | Default | Description |
|---|---|---|
| Ollama URL | http://localhost:11434 |
Base URL of your Ollama instance |
| Chat Model | deepseek-v4-flash |
Model used for normal chat, Ask mode, and Research mode |
| Agent Model | glm-5.1 |
Model used for Edit, Organize, Workflow, and auto-organizer tasks |
| Default Agent Mode | Ask |
Default chat mode (Ask, Edit, Organize, Research, Workflow) |
| Vault Search Limit | 5 |
Maximum number of vault entries to include in context |
| Max Context Length | 8000 |
Maximum characters of vault content sent to the AI per message |
| Max Message History | 50 |
Maximum number of messages kept in conversation history |
| Enable Vault Semantic Index | Off | Index vault notes into a vector DB for semantic/RAG search |
| Vault Index ChromaDB URL | http://localhost:8000 |
URL of your ChromaDB instance for the vault index |
| Vault Index Embedding Model | nomic-embed-text |
Ollama model used to generate vault embeddings |
| Vault Index Similarity Threshold | 0.75 |
Minimum cosine similarity (0–1) for a vault search hit |
| Rebuild Vault Index | — | Button to rebuild the entire vault semantic index |
| Clear Vault Index | — | Button to delete all indexed vault notes |
| Enable Semantic Cache | Off | Cache responses for fast repeated queries |
| ChromaDB URL | http://localhost:8000 |
URL of your running ChromaDB instance |
| Cache Embedding Model | nomic-embed-text |
Ollama model used to generate cache embeddings |
| Cache Similarity Threshold | 0.85 |
Minimum cosine similarity (0–1) for a cache hit |
| Clear Semantic Cache | — | Button to wipe all cached responses |
| Enable Auto-Tagging | Off | Automatically suggest and apply tags to untagged notes |
| Max Tags Per Note | 5 |
Maximum tags to generate per note |
| Normalize Tags | On | Normalize generated tags against existing vault vocabulary |
| Target Folder (Auto-Tag) | — | Restrict auto-tagging to a specific folder |
| Enable Auto-Linking | Off | Add "Related Notes" sections based on semantic similarity |
| Max Links Per Note | 3 |
Maximum related note links to insert |
| Target Folder (Auto-Link) | — | Restrict auto-linking to a specific folder |
| Dry Run Mode (Auto-Link) | Off | Preview proposed links without applying them |
| Enable Structured Memory | On | Inject remembered context from past sessions into prompts |
| Max Conversation Summaries | 10 |
Maximum past conversation summaries to retain |
| Max User Preferences | 20 |
Maximum user preferences to retain |
| Max Learned Facts | 50 |
Maximum learned facts to retain |
| Clear Structured Memory | — | Button to delete all stored memory |
| Enable Tool Telemetry | On | Record tool calls, searches, and LLM token counts |
| Max Telemetry Entries | 100 |
Maximum telemetry events to retain |
| Clear Tool Telemetry | — | Button to delete all recorded telemetry |
Usage
- Open the chat view via the command palette (
Ctrl+P→ "Open Ollama Chat") or the ribbon icon - Type your message in the input box
- Press Enter or click Send to send your message
- Press Shift+Enter to insert a line break
- Click New Chat to start a fresh conversation
Agent Modes
The chat view includes a mode selector dropdown. Each mode changes the assistant's behaviour:
| Mode | Tools Available | Preview Required | Use Case |
|---|---|---|---|
| Ask | Read, Search | No | Answer questions using vault context |
| Edit | All tools | Yes | Create, modify, and manage notes |
| Organize | Read, Search, Frontmatter, Rename, Move, Link | Yes | Tag, rename, move, and link notes |
| Research | Read, Search | No | Deep vault search and synthesis |
| Workflow | None (uses /workflow) |
No | Execute multi-step AI workflows |
When a mode requires preview (Edit, Organize), write operations like create_note or delete_note show a card with a before/after diff and Apply / Cancel buttons. Ask and Research modes execute write tools immediately without preview.
Workflows
Type /workflow followed by a description to trigger the workflow engine. The AI will generate a multi-step workflow plan, then execute it step-by-step. Example:
/workflow Find all notes tagged "meeting", summarise them, and create a "Meeting Summary" note
Auto-Organizer
Use the command palette to trigger:
- Auto-Tag Untagged Notes — AI generates tags for notes missing tags
- Auto-Link Related Notes — AI inserts "Related Notes" sections with wiki-links
Both features support:
- Dry-run mode — preview proposed changes without modifying the vault
- Target folder — restrict processing to a specific folder and its subfolders
- Tag normalisation — match generated tags against existing vault vocabulary
Commands
| Command | Description |
|---|---|
| Open Ollama Chat | Open the chat sidebar |
| Clear Semantic Cache | Delete all cached responses |
| Clear Vault Index | Delete all indexed vault notes |
| Rebuild Vault Index | Rebuild the vault semantic index from scratch |
| Auto-Tag Untagged Notes | Run the auto-tagger |
| Auto-Link Related Notes | Run the auto-linker |
| Clear Structured Memory | Delete all conversation summaries, preferences, and facts |
| Clear Tool Telemetry | Delete all recorded telemetry events |
Semantic Cache Behaviour
- The cache is bypassed when tool calls are involved (e.g. file creation), since those requests have side effects.
- Responses are stored against the last user message in the conversation. If a new query is sufficiently similar (above the configured threshold), the cached response is returned.
- Re-asking the same question updates the existing cache entry rather than creating a duplicate.
- Use the Clear Semantic Cache button in settings to remove all stored responses (for example after switching embedding models).
Vault Context
When you send a message, the plugin searches your vault for relevant notes and includes them as context. If the Vault Semantic Index is enabled, search is performed via semantic/RAG retrieval using vector embeddings. Otherwise, it falls back to a weighted keyword search:
- Headings — 5x weight
- Frontmatter title — 3x weight
- Frontmatter tags — 2.5x weight
- First paragraph — 1.5x weight
- General content — 1x weight
The plugin also pulls in:
- Explicit mentions — notes referenced via
[[...]]wikilinks in the message - Open note — the currently active note
- Selected text — text selected in the active editor
- Backlinks / Outlinks — notes that link to / from the open note
- Related notes — semantically similar notes (requires vault semantic index)
The plugin automatically watches your vault for changes (create, modify, delete, rename) and updates the semantic index in real time when enabled.
Frontmatter, tags, links, and headings are resolved using Obsidian's built-in metadataCache API for accuracy and performance.
Tools
The assistant has access to a suite of tools that interact with your vault. Available tools depend on the current Agent Mode:
| Tool | Description | Mode |
|---|---|---|
create_note / create_file |
Create a new markdown file | Edit |
read_vault_file |
Read the contents of a note | All |
search_vault_files |
Keyword-search vault files by path | All |
append_to_note |
Append text to the end of a note | Edit |
replace_note_section |
Replace content under a specific heading | Edit |
update_frontmatter |
Add, update, or remove frontmatter fields | Edit, Organize |
rename_note |
Rename a note file | Edit, Organize |
move_note |
Move a note to a different folder | Edit, Organize |
delete_note |
Delete a note | Edit |
insert_link |
Insert a [[wiki-link]] into a note |
Edit, Organize |
Paths are validated for safety: no .obsidian/.git access, no path traversal (..), no absolute paths, and a 200-character limit.
Structured Memory
When Enable Structured Memory is on, the plugin remembers context across sessions by storing three kinds of data in Obsidian's plugin data JSON:
- Conversation Summaries — After each assistant reply, a brief summary (topic + key points) is saved
- User Preferences — Statements like "I prefer dark mode" or "My favourite colour is blue" are extracted and stored
- Learned Facts — Simple facts mentioned in conversation (e.g., "Obsidian is a note-taking app") and vault folder paths are remembered
These are injected as a system message at the start of every LLM call, so the assistant "remembers" context from previous sessions. Limits and clear controls are available in settings.
Tool Telemetry
When Enable Tool Telemetry is on, the plugin records:
- Tool calls — which tool, arguments, success/failure, result summary, and duration
- LLM calls — model, estimated prompt/completion/total tokens, and duration
- Vault searches — query, number of results, and matched note paths
Telemetry is stored locally in Obsidian's plugin data. The settings tab shows a Recent Activity summary of the last 10 events. Use Clear Tool Telemetry to wipe the history.
Note: Token counts are exact when Ollama provides
prompt_eval_countandeval_countin its response; otherwise they are estimated from character count (÷4 approximation).
Supported Models
Any Ollama-supported model works. Popular choices:
llama3llama2mistralcodellama- and many more — see ollama.com/library
Development
npm install
npm run build
npm test # 520+ unit tests across 21 test suites
npm run lint # ESLint check
The project uses TypeScript, Jest, and esbuild. Obsidian APIs are mocked in __mocks__/obsidian.ts for testing.
Troubleshooting
| Symptom | Likely cause | Fix |
|---|---|---|
| Plugin doesn't appear in Obsidian | Install script was not run or failed | Run ./install.sh /path/to/vault and reload Obsidian |
| Cannot connect to Ollama | Ollama is not running | Run ollama serve |
| Model not found | Model not pulled | Run ollama pull <model> |
| "Invalid response format" error | Ollama returned a non-JSON response (e.g., proxy error page) | Check that Ollama is healthy at the configured URL |
| Semantic cache unavailable (notice shown) | ChromaDB is not running, or the ChromaDB URL is wrong | Start ChromaDB (chroma run) and verify the URL in settings |
| Cache always misses | Similarity threshold is too high, or the embedding model was changed | Lower the threshold or click Clear Semantic Cache and let the cache rebuild |
| Slow first response after enabling cache | Embedding model not yet pulled | Run ollama pull nomic-embed-text (or the model you configured) |
| Permission issues | Vault write permissions | Check that your Obsidian vault has proper write permissions |
| Structured memory not showing up | Memory was just cleared or is empty | Have a few conversations — summaries are generated after each assistant reply |
| Tool telemetry not recording | Telemetry is disabled or max entries is 0 | Enable Tool Telemetry in settings and set Max Telemetry Entries > 0 |
Security
- File paths are validated to prevent access to
.obsidian/and.git/directories - Path traversal attempts (
..) are blocked - Absolute paths and Windows drive letters are rejected
- Maximum path length is enforced (200 characters)
License
MIT License
Copyright (c) 2024 Flo Egger
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.