Build a knowledge base that grows itself

Most "second brain" setups die the same way: you build it, you're excited for a week, and then you stop feeding it. The fix isn't more discipline — it's removing yourself from the loop. A self-growing knowledge base researches new topics on a schedule and ingests them automatically, so it gets more useful while you sleep. Here's the architecture I actually run, and how to build your own.

The 30-second version

  • Store: a vector database (Pinecone) holds your knowledge as embeddings you can search by meaning, not keywords.
  • Brain: an LLM (Gemini, Claude, or GPT) does the embedding and answers your questions with citations.
  • Engine: n8n runs two scheduled loops — one that answers (RAG) and one that grows the base by researching new topics and ingesting them.
  • The growth loop pulls from a self-refilling queue so it never runs dry and never drifts into nonsense.

Why "self-growing" matters

A normal RAG setup retrieves from a fixed pile of documents. Useful, but static — it only knows what you fed it. The upgrade is a scheduled agent that asks, on its own, "what should I learn next?" and then goes and learns it. Over weeks, the base compounds: it gets deeper in the areas you care about without you lifting a finger.

The architecture, piece by piece

1. Ingestion. Documents (notes, research, transcripts, web results) get chunked, embedded with your model, and upserted into Pinecone with metadata so you can filter and cite.

2. Retrieval + answer. A query gets embedded, Pinecone returns the closest chunks, an optional reranker sharpens the order, and the LLM writes a cited answer. That's classic RAG.

3. The growth loop (the part that makes it "self-growing"). On a schedule, the agent reads its own coverage and proposes the next research topics — then runs grounded research and ingests the results. Run it morning and evening and the base adds a few fresh, cited documents every day.

4. The refill queue. This is the trick that keeps it from drifting. Instead of inventing random topics, the agent proposes work in three flavors: depth (deepen something already covered), synthesis (connect two existing topics), and gaps (fill a known hole) — always referencing what's already there. So the foundation builds on itself instead of wandering off.

Skip the architecture work: the build guide

I packaged the whole blueprint — the loops, the schemas, the refill-queue logic, the cron schedule, and the gotchas — into a single guide so you can stand one up without reverse-engineering it.

Get the Self-Growing KB Guide — $49 →

Instant download, per-buyer license. It pairs well with the import-and-go workflows in the n8n template shop.

What you'll need

  • A Pinecone account (free tier is plenty to start).
  • An LLM API key — Gemini, Claude, or OpenAI all work.
  • An n8n instance to run the scheduled loops. New to it? Here's why n8n beats Zapier/Make for this.

Bottom line

A second brain only pays off if it keeps growing without you. Pair a vector store, an LLM, and a scheduled research loop with a self-refilling queue, and you get a knowledge base that compounds on its own. Build it from the outline above, or grab the build guide and skip the trial-and-error.

Related: track hedge fund & congress trades automatically · automations that pay for themselves.

Frequently asked questions

What is a self-growing knowledge base?
It's a vector knowledge base (a 'second brain') paired with a scheduled agent that researches new topics on its own and ingests the results — so the knowledge base keeps expanding without you manually adding documents. You query it with natural language and get cited answers.
What tools do you need to build one?
A vector database (Pinecone), an embedding + generation model (Gemini, OpenAI, or Claude), and an orchestrator to run the scheduled research and ingestion loop (n8n). That's the whole stack — everything else is glue.
How does it 'grow itself' without going off the rails?
A refill queue. Instead of inventing random topics, the agent proposes new research that deepens areas you already cover, connects two existing topics, or fills a known gap — referencing what's already in the base. That keeps growth compounding on your foundation instead of drifting.
Is this the same as RAG?
It uses RAG (retrieval-augmented generation) for answering, but adds an autonomous ingestion loop on top. Standard RAG retrieves from a fixed corpus; a self-growing KB continuously expands that corpus on a schedule.

Ready to build a brain that grows itself?

The full architecture, loops, and refill-queue logic in one guide.

Get the occasional build tip

New n8n templates, automation breakdowns, and the odd freebie. No spam, unsubscribe anytime.