Building a Personal AI Knowledge Base

Generic AI knows everything about the world and nothing about your business. It does not know your clients, your pricing, your past decisions, or the context behind your work. A personal AI knowledge base fixes that.

This guide is for solopreneurs and knowledge workers who want AI responses grounded in actual business context, not confident guesses.

What a Personal AI Knowledge Base Actually Is

A personal AI knowledge base is a structured collection of your own knowledge, made queryable by AI at the moment it generates a response. It is not a chatbot UI. It is not another app to open. It is a layer that sits behind every AI interaction and answers the question: "What does this AI need to know about me and my work to give a useful response?"

The difference in practice:

• Generic AI: "Write a proposal for a new client." Produces a generic template.
• AI with your knowledge base: "Write a proposal for a new client." Produces a draft using your actual pricing, your past proposal language, your client's industry context, and notes from your last call.

The gap between these two outputs is why knowledge base setup is worth the investment.

Three Approaches, Ranked by Complexity

1. Structured Notes with Context Injection (Simplest)

You maintain a set of documents in Notion, Obsidian, or plain markdown files. Before each AI session, you paste or inject relevant sections as context.

How it works: You build a "context document" for each client or project. When you start a new AI task, you paste that document into the system prompt or conversation start.

Best for: Solopreneurs with fewer than 20 active clients or projects. Low setup cost, immediate results, no infrastructure.

Limitation: Manual. You decide what context is relevant. Does not scale past a few dozen documents.

Cost: $0 beyond your existing Notion or Obsidian subscription.

2. RAG with Embeddings (Middle Ground)

RAG (Retrieval Augmented Generation) means the AI searches your knowledge base automatically before responding. You store documents as vector embeddings, and at query time the system pulls the most relevant chunks to include as context.

How it works:

1. You chunk your documents (meetings notes, emails, SOPs, client briefs) into 300 to 500 token segments.
2. Each chunk is converted to an embedding (a vector of numbers that represents its semantic meaning).
3. Those embeddings are stored in a vector database.
4. When you ask a question, your query is also converted to an embedding, and the database returns the most similar chunks.
5. Those chunks are injected into the AI's context window automatically.

Tools:

• Supabase pgvector: Easiest starting point. Your knowledge base lives in a Postgres table with a vector column. Free tier handles thousands of documents. $25/month on the Pro plan.
• Chroma: Open source, runs locally, zero cost. Good for personal use where you want full control. Requires a bit more setup.
• Pinecone: Managed vector database. Generous free tier (100k vectors). Use this if you want a hosted solution without running your own Postgres instance.

Embedding model: Use text-embedding-3-small from OpenAI ($0.02 per million tokens) or voyage-3 from Voyage AI (slightly better quality for retrieval tasks, similar pricing). Embedding your entire document library costs pennies.

Example chunk retrieval in practice:

# Query your knowledge base before sending to Claude
query = "What did we decide about the pricing model for Acme Corp?"
chunks = knowledge_base.search(query, top_k=5)
context = "\n\n".join([c.text for c in chunks])
prompt = f"Context from your files:\n{context}\n\nQuestion: {query}"

Cost: $0 to $25/month for storage. Embedding costs are negligible. LLM costs are your main variable.

3. MCP Memory Servers (Most Integrated)

MCP (Model Context Protocol) lets you expose your knowledge base as a tool that Claude or any MCP-compatible client can call directly, within the conversation, without you doing anything manually.

How it works: You run a local or hosted MCP server that exposes tools like search_memory, save_note, and list_clients. The AI calls these tools mid-conversation when it needs information.

What this enables: The AI can look up client history, save new information, and retrieve past decisions, all within a single conversation, without you pasting anything.

See the full breakdown of MCP tool ecosystems in the MCP Tool Ecosystems guide.

Cost: Free if self-hosted. Requires comfort with running a local server or deploying a small Node or Python service.

What to Feed Your Knowledge Base

The quality of your knowledge base depends entirely on what you put in it. Priority order:

1. Client briefs and onboarding notes: Scope, goals, constraints, preferences, communication style.
2. Meeting notes and call transcripts: Use Otter.ai, Fathom, or Fireflies to auto-transcribe. Export and chunk.
3. Past deliverables: Proposals, reports, copy you have written. Gives AI your style and standards.
4. SOPs and processes: How you do your work. Lets AI help you follow your own systems.
5. Email threads (selective): Key decisions, commitments, context. Do not dump your entire inbox.
6. Domain knowledge: Articles, books, or research you have read and want AI to reference.

Avoid: Raw email threads without curation. Social media posts. Anything you would not want referenced in a professional context.

How to Query It in Practice

A knowledge base only helps if it surfaces the right information at the right time. Two practical patterns:

Pattern 1: Project kick-off prompt At the start of any client work, query your knowledge base for that client name and paste the top 3 to 5 chunks into your system prompt. Everything in that session is now grounded in your history with them.

Pattern 2: Automatic retrieval in an agent If you run agents for recurring tasks (content drafts, proposal generation, research summaries), wire knowledge base retrieval into the agent's first step. The agent pulls relevant context before doing anything else.

When to Use Embeddings vs. Just Good Prompting

Embeddings are not always the right answer. Use this decision rule:

• Fewer than 20 documents, stable content: Paste them directly into your system prompt. No infrastructure needed.
• 20 to 200 documents, mixed relevance: RAG makes sense. You cannot paste everything, but the knowledge base is small enough that Supabase pgvector handles it trivially.
• 200+ documents, or frequent updates: Full RAG pipeline with automated ingestion. Worth setting up proper chunking and a scheduled update job.

For most solopreneurs starting out, good prompting with a well-maintained context document beats a half-built RAG system. Build the infrastructure when you have enough documents that manual management breaks down.

The Simplest Version That Actually Works

If you want to start today with zero infrastructure:

1. Create one Notion page per active client. Include: what they do, what you are working on, key decisions, and anything the AI should always know.
2. Create a [YOUR NAME] context document with your pricing, your process, your tone, and your business model.
3. Build a Claude Project (in Claude.ai) and upload these documents to the project knowledge. Claude will reference them automatically in every conversation in that project.
4. When you start a new task, type the client name. Claude will retrieve the relevant context from the project files.

This costs nothing beyond your Claude subscription. It is not a perfect RAG system. But it works, and you will learn what you actually need to retrieve before building anything more complex.

Maintenance

A knowledge base that is not maintained becomes noise. Simple rules:

• After every client call: add a 2 to 3 sentence summary to that client's page.
• After every project: write a one-paragraph retrospective and file it.
• Monthly: remove or archive stale documents. Outdated information misleads AI as much as it misleads humans.
• When pricing or process changes: update the relevant document immediately.

Treat your knowledge base like a living document, not an archive.

Related Guides

• The 2026 Solopreneur AI Stack: Full tool recommendations including Supabase and the infrastructure layer your knowledge base runs on.
• MCP Tool Ecosystems: How to expose your knowledge base as an MCP tool and give AI direct access to your memory mid-conversation.