your second brain should not be a folder full of markdown

I like markdown. I really do.

Markdown is simple, portable, git-friendly, easy to back up, and great for writing. But I also think a lot of “second brain” tools quietly fall apart at the exact moment they are supposed to become useful.

They work nicely while your memory is small. Then one day you want to find that one thing:

• the exact hour you went to the gym three Tuesdays ago
• the bakery you liked in a city you visited once
• the detailed advice a friend gave you in a long conversation six months ago
• that random insight you had during a walk and saved from your phone

And suddenly your “second brain” is just a polite pile of files.

That is the moment where I think most markdown-first memory systems reveal their real limitation:

they are optimized for storing text, not for retrieving memory.

That is why I find Jurupari interesting. Not because it adds more note-taking ceremony. Quite the opposite. Because it strips the idea down to what actually matters:

• store memories in a real database
• search them semantically
• expose them through MCP and HTTP
• let any AI tool read and write them for you

That is much closer to what a real second brain should be.

the problem with markdown second brains

A folder full of notes feels smart at first. Engineers especially love it because it feels open and under control. No vendor lock-in, no weird proprietary format, just files.

I get the appeal. I have that instinct too.

But once memory stops being “a few documents I can browse manually” and becomes “an extension of my day-to-day thinking,” files start getting awkward.

The problem is not that markdown is bad. The problem is that memory retrieval is a search problem, and search gets much better when you treat it like a database problem instead of a filesystem hobby.

If your idea of memory is:

• searchable history
• timeline fragments
• personal facts
• recurring preferences
• conversation details
• lightweight journaling
• structured and unstructured recall

…then embedded search plus a proper data model beats filename gymnastics every time.

what jurupari gets right

Jurupari is basically a very simple personal knowledge base with the right primitives:

• PostgreSQL for storage
• pgvector for semantic search
• MCP so AI tools can use it directly
• HTTP API for direct integration and automation
• CRUD support, not just retrieval

That last part matters a lot. A lot of “memory” integrations are glorified search adapters. They can retrieve context, maybe rank snippets, maybe inject them into a prompt. But they cannot really behave like a durable memory system because writing is awkward or missing.

Jurupari fixes that.

With MCP in front of it, memory stops being a manual note-taking ritual and becomes something much more natural:

Hey, save this on my Jurupari memory.

That is the right abstraction. I do not want to stop what I am doing, open another app, decide on a folder, decide on a title, decide on tags, and become my own archivist. I want memory capture to be cheap.

If the system is good, I should be able to talk to Claude, GPT, OpenClaw, Hermes, n8n, or any other MCP-capable tool and say:

• save this
• find that
• update this
• remove that

That is a second brain. Not a graveyard of notes.

semantic search is the real feature

The real power here is not “you can store notes in Postgres.” That part is almost boring.

The real feature is that semantic search changes how you interact with memory.

You do not need to remember the exact words you used. You just need to remember what you meant.

That is a huge difference.

A filesystem usually rewards perfect recall:

• correct filename
• correct folder
• correct keyword
• correct tagging habit

A semantic memory system rewards approximate recall:

• “find that thing I wrote about feeling tired after leg day”
• “what was the coffee place I liked near the station?”
• “search my memory for that conversation about changing jobs”
• “what did I say last month about sleep quality?”

That is much closer to how human memory actually works.

this is where a second brain becomes actually useful

A lot of “second brain” marketing is weirdly grandiose. It talks like you are building a digital philosopher king inside your laptop. I do not think that is the useful framing.

The useful framing is much simpler:

your memory gets more valuable when it becomes easy to save and easy to find.

That means very normal things suddenly become worth recording.

For example:

1. everyday activity logging

You want to remember what time you did something. Not because it is deep or poetic, but because reality is slippery.

Examples:

• what time did I go to the gym?
• when did I stop by the bakery?
• what time did I take the dog out?
• when did I last call my parents?

Prompt examples:

Save this on my Jurupari memory: I went to the gym today at 07:10.

Save this memory: I went to the bakery at 08:35 and bought sourdough and two pastéis de nata.

Later:

Search my Jurupari memory for the last time I went to the gym in the morning.

2. detailed conversations

Sometimes the most useful thing to remember is not a task. It is context.

Maybe a friend told you something important. Maybe you had a subtle conversation with your partner. Maybe someone gave you advice that only makes sense when you preserve the detail.

Prompt examples:

Save this on my Jurupari memory: today I talked to Daniel for an hour. He said he is thinking about leaving his job because the team structure changed, he feels blocked by management, and he wants to move closer to product strategy.

Later:

Find my memory about Daniel thinking of leaving his job.

That is way better than hoping you named the note career-chat-daniel-maybe-job-change-final-final.md.

3. journal entries that you can actually recover

This is the part I like most. Jurupari can work like a journal, but not the kind of journal you write and then lose inside your own archive.

You can keep small fragments of life:

• what made you anxious today
• what went well this week
• a lesson from a hard conversation
• a small win you want to remember
• a pattern you are noticing in your energy, habits, or mood

Prompt examples:

Save this memory: I felt unusually focused today after sleeping 8 hours and going for a 20-minute walk before work.

Search my memory for patterns involving focus, sleep, and walking.

That is where the “second brain” idea stops being branding and starts becoming practical.

mcp is what makes this feel native instead of bolted on

The reason this gets much more interesting now than a few years ago is MCP.

Without MCP, a memory system is usually another app you have to remember to use. With MCP, memory becomes part of the interface layer of your AI tools.

That changes behavior.

Instead of thinking:

I should go open my note system and save this.

You think:

Hey, save this.

That is a much lower-friction action. And low friction is everything for personal memory systems. Because the best memory tool is not the one with the fanciest graph view. It is the one you actually keep feeding.

Jurupari is especially nice here because it is not trying to trap you inside one product surface. You can plug it into:

• Claude
• GPT
• OpenClaw
• Hermes
• n8n
• other MCP-capable tools

So the memory follows your workflow instead of demanding a new one.

the real second brain is writable

I think this is the most underrated idea in the whole space.

A real second brain cannot be read-only.

If an AI can search your memory but cannot update it, correct it, append to it, or save new facts when you ask, then it is not really your second brain. It is just a retrieval plugin.

Jurupari exposing CRUD through MCP is the important design choice. That is what makes these flows possible:

Save this on my Jurupari memory: the plumber said he will come on Friday between 14:00 and 16:00.

Update that memory: the plumber moved it to Saturday at 10:30.

Delete the duplicate note about the bakery. Keep the one with the exact time.

That sounds small, but it is the difference between “search over notes” and “persistent memory you can manage conversationally.”

how to run your own jurupari

The nice part is that this is not some giant infrastructure project. The repo is refreshingly direct.

At a high level, the setup is:

1. deploy Jurupari somewhere you like
2. point it at a PostgreSQL database with pgvector
3. set your environment variables
4. run the API
5. expose MCP so your AI tools can connect to it

From the project README, the local dev flow is basically:

cp .env.example .env
# fill DATABASE_URL, OPENAI_API_KEY, JURUPARI_TOKEN

docker compose up -d
pnpm install
pnpm db:push
pnpm dev:api
pnpm --filter @jurupari/mcp build && node packages/mcp/dist/index.js

And if you want a simple hosted version, the project explicitly mentions deployment on places like AWS or Railway.

The mental model is straightforward:

• Postgres + pgvector stores and indexes your memory
• the API gives you direct application access
• the MCP server lets AI clients talk to the memory naturally
• the token model controls read/write access

There is also a nice split between remote and local MCP setups:

• Remote SSE for web clients and remote integrations
• Local stdio for tools like Claude Desktop, Claude Code, or Cursor

That means you can choose convenience or locality depending on your setup.

who this is for

I think Jurupari makes the most sense for people who:

• already use AI tools every day
• are tired of fragmented personal context
• want memory to be available across tools
• prefer owning their own stack
• understand that retrieval quality matters more than note aesthetics

Especially engineers. Because engineers often over-romanticize plain files and under-invest in retrieval.

I say that with love. We do this all the time. We will build a beautiful directory tree and call it knowledge management, then act surprised when finding anything becomes annoying.

my take

If you want a writing system, markdown is still fantastic. If you want a durable searchable memory that can live behind your favorite AI tools, markdown folders are usually the wrong center of gravity.

That is why I think Jurupari is a much more honest version of the “second brain” idea.

It does not pretend memory is about collecting pretty notes. It treats memory like what it actually becomes at scale:

• a search problem
• a retrieval problem
• a write problem
• a data-model problem
• an interface problem

And once you see it that way, the architecture becomes obvious.

Use a real database. Use semantic search. Expose CRUD. Plug it into the tools you already talk to.

That is much closer to a real second brain than a synced folder full of markdown will ever be.

references

• Jurupari GitHub repository — https://github.com/brazanation/jurupari
• Jurupari README — https://raw.githubusercontent.com/brazanation/jurupari/main/README.md