Obsidian / ChatGPT / PythonGitHub
Obsidian Automation.
I started using Obsidian while I was learning a few different subjects. It’s a good place to keep notes, ideas and research, and I liked the idea of it being somewhere I could keep things worth remembering.
One thing I liked about Obsidian was that my notes were ordinary Markdown files stored on my own computer. I could open them in another editor, work with them using other software, or reorganize them without being tied to a particular application. I also keep the entire vault under version control in a private GitHub repository, so I can track changes and recover earlier versions.
Around the same time I was having long conversations with ChatGPT while I worked things out. Every so often one of them produced an explanation, a decision, or some information I wanted to keep. Keeping it meant copying it into Obsidian, or writing the note myself.
After doing that enough times, I wondered why I couldn’t connect the two directly. That led to a few experiments and, eventually, a Python toolkit.
- A ChatGPT conversation
- Select
- Copy
- Paste
- An Obsidian note
Fig. 01
It ended up being useful for more than saving conversations
Once ChatGPT could read the vault, the notes stopped being a place I filed things and became something I worked from. I use ChatGPT for the thinking: discussion, research, planning, and reviewing work critically. The vault holds what comes out of that. Codex and Claude Code do the implementation in the actual repositories.
A Keeping what’s worth keeping
ChatGPT reasoning
Talk something through. When part of it is worth keeping, it becomes a new note.
Obsidian vault memory
Explanations, research, decisions, rules.
Codex · Claude Code implementation
Documentation gets updated when the work changes it.
B Working from what’s been written down
ChatGPT reasoning
Reads the notes that apply and reviews a proposed change against them.
Obsidian vault memory
The requirements, the process rules, and the specific change.
Codex · Claude Code implementation
Take one focused task into the repository and make the change.
The result can go back to ChatGPT for another review, and the notes get updated where that’s warranted.
The part I didn’t expect was what it did to my coding-agent usage. When I reason through a design inside Codex or Claude Code, the long deliberation is what uses up my allowance, far more than the implementation does. In my experience, moving the substantial planning and review work into ChatGPT, backed by notes it can read, and then giving an agent a narrow task has substantially reduced how much of my Codex and Claude Code usage I go through.
An example
One change, checked against three notes
This is a real, completed change from a personal software project I’m still working on. The project is private, so I’ve kept this to one change from June 2026 and a few lines from its notes.
The problem, in plain terms: one part of the app needed to stop other code from treating an ordinary result as permission to create a new prompt. The requirements for that already existed in Obsidian. The work was checked against them, instead of letting the existing code decide what was correct. The three notes below have separate jobs, and the original wording is kept for anyone who wants to read it closely, with two bracketed terms swapped for plainer ones.
What the work has to satisfy
Architecture requirements Accepted authority
new [prompt] commitment requires positive source-backed permission to commit; absence of a blocker is not permission…
Nothing moves forward just because nothing objected.
How the work is allowed to be done
Process rules How changes are shaped and reviewed
Existing repo machinery is evidence only. It does not define, preserve, narrow, reinterpret, delay, or veto accepted authority.
The existing code doesn’t get a vote on the requirements.
Which code to change
Implementation instructions One focused change
A hand-built [admission result] with identical field values is a different object and is not registered.
Permission has to come from the step that actually checked.
What the instructions found in the code
Any caller could construct a “permission granted” result. The instructions found six hand-built ones, all in tests, so those tests were skipping the step that’s supposed to do the checking. They also settled a second question up front: a result that proves a prompt is already open is not permission to create a new one.
What landed a completed change; this area of the code has evolved since
Merged 29 June 2026 · six files · +255 −248
- The commitment step now refuses any result that didn’t come from the admission step.
- A new test rejects a hand-built positive result.
- Another rejects a valid continuation result as authority to create.
- Admission results are frozen once built.
The pull request carries a short record of the governing note, the code changed, the invariant enforced, what was left out, and the commands run. The tests and lint for the change passed, and nothing had to go back to the requirements for revision.
I can ask ChatGPT to review a proposed change against documents like these, each with a different responsibility. The implementation instructions reference the governing requirements directly, so the coding agent can work from an established task rather than reconstructing the discussion.
The toolkit
What’s behind the connector
It’s a Python package with three separate parts. A client talks to the Obsidian Local REST API plugin. A command-line interface does the vault operations. An optional MCP server exposes the safe subset of those operations to ChatGPT’s connector. Plenty of the everyday operations, like tag searches, work straight from the files without Obsidian open. The coding agents don’t use the connector. They work on the files, and the CLI is there too.
- Narrow by default. The default MCP profile is read-only. A second profile adds exactly one write, creating a new note and never overwriting one, and that’s what lets ChatGPT save notes to the vault. It can’t edit, move or delete anything.
- Destructive operations are planned first. A removal or move produces a plan, then runs only with the approval and drift-check tokens that plan issued, and it’s logged. Direct deletes are off unless I turn them on, and none of this is exposed over MCP.
- The vault stays the source of truth. A rebuildable SQLite index gives notes stable IDs and short references.
The public repository is the general-purpose version. Where my own copy runs and how ChatGPT reaches it aren’t part of it.
View the source on GitHub
MIT licensed. The README and architecture notes go much deeper than this page.
$ python -m obsidian_automation.cli search_notes_by_tag --tag research
{
"ok": true,
"command": "search_notes_by_tag",
"result": {
"tag": "research",
"matches": [
{
"path": "Notes/Reading.md",
"matched_sources": ["frontmatter"]
}
],
"match_count": 1
}
}$ python -m obsidian_automation.mcp_server \
--transport streamable-http \
--host 127.0.0.1 --port 8765I didn’t build this as something to keep working on. What I wanted was for it to work reliably enough that I stop thinking about it, and mostly it does. It’s one of the more useful things I’ve made, and it started with not wanting to paste text into a note.