Poshmarkedbudu.

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.

  1. A ChatGPT conversation
  2. Select
  3. Copy
  4. Paste
  5. An Obsidian note
The middle three were the part I wanted to stop doing.

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.

I’m the one moving between them. ChatGPT and the coding agents have different jobs, and the vault is what they have in common. Nothing here runs on its own: the Python tooling gives access to the notes and doesn’t direct any of the agents.

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.

  1. 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.

  2. 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.

  3. 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.

Finding notes by tag from the CLI, against a scratch vault
$ 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
  }
}
Running the MCP server locally
$ python -m obsidian_automation.mcp_server \
    --transport streamable-http \
    --host 127.0.0.1 --port 8765

I 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.