AI Knowledge Base Setup: Build Context Your AI Can Read

Updated January 2026 | 7 min read

You've re-explained your business structure 47 times to ChatGPT. Every new conversation starts from zero. Your AI forgets your pricing, your clients, your workflow. It gives you generic output because it doesn't know who you are.

The problem isn't the AI. It's the knowledge base.

Most people store business knowledge in Notion, Google Docs, or their head. None of these formats load into an AI conversation. Your notes sit in one app while your AI sits in another, completely disconnected.

Why Traditional Knowledge Bases Don't Work with AI

Notion is great for human reading. Terrible for AI context.

Google Docs are searchable by you. Invisible to your AI assistant.

Even if you copy-paste information into chat, it doesn't persist. Next conversation, you start over.

The AI knowledge base setup that works requires three things:

1. Structured markdown files (not proprietary formats)
2. A file system your AI can read at session start
3. Context routing that loads relevant information automatically

This isn't about uploading documents to ChatGPT. That's temporary context that expires. This is about building a persistent memory system.

The Architecture: How File-Based Context Works

Claude Code can read local files. That's the entire foundation.

When you start a conversation, Claude Code loads a CLAUDE.md file from your vault. That file contains:

• Who you are (name, job, schedule)
• What you do (business domains, clients, projects)
• How you work (voice guidelines, frameworks, tools)
• Where to find more (paths to domain-specific context files)

Every conversation starts with this context already loaded. No re-explaining. No "remember I told you about..."

The AI already knows.

Step-by-Step: Building Your AI Knowledge Base

1. Choose Your Tools

You need two things:

• Obsidian (free note-taking app, works with plain markdown files)
• Claude Code (Anthropic's CLI for Claude, requires Claude Pro subscription)

Why Obsidian? It stores notes as plain .md files in a folder on your computer. No database lock-in. No proprietary format. Just files Claude Code can read.

Why Claude Code? It's the only AI interface that loads local files at session start automatically.

2. Create Your Vault Structure

Open Obsidian. Create a new vault. Set up folders by domain:

/YourVault/
  CLAUDE.md (master context file)
  /Work/
    _context.md (work-specific info)
  /Clients/
    _context.md (client details)
  /Projects/
    _context.md (active projects)

The underscore prefix on context files signals "this is for AI, not humans."

3. Write Your CLAUDE.md File

This is the master file. Keep it under 3,000 words. Structure it like this:

## WHO
[Your name, role, business, schedule]

## WHAT
[What you do, domains you operate in]

## WHERE
[Paths to domain-specific context files]

## VOICE
[How you want AI to communicate]

## RULES
[Non-negotiable guidelines]

Be specific. Don't write "I run a marketing agency." Write "I run Scale With Search, an SEO education business. Four clients on monthly retainers: Cryo Body Works, Limitless Chiro, Valley Welding, Ke'ale Chiro. Deliverables: content briefs, articles, topical maps."

The more specific you are, the better your AI performs.

4. Build Domain Context Files

Each folder gets a _context.md file with domain-specific details.

For a client folder:

## Client: Cryo Body Works
Location: Raleigh, NC
Services: Cryotherapy, infrared sauna, compression therapy
Voice: Professional but approachable, health-focused
Keywords: recovery, inflammation, wellness
Content Schedule: 2 articles/month

For a project folder:

## Project: Website Redesign
Client: Valley Welding
Deadline: 2026-02-15
Tech Stack: Static HTML, hosted on Netlify
Brand Colors: #1a1a1a, #ff6b00

These files don't load automatically. Your CLAUDE.md file tells the AI when to load them based on keywords in your prompt.

5. Set Up Context Routing

This is the magic. In your CLAUDE.md file, add a routing table:

## CONTEXT ROUTING

| Keyword | Load File |
|---------|-----------|
| "Cryo" or "cryotherapy" | /Clients/Cryo/_context.md |
| "Valley" or "welding" | /Clients/Valley/_context.md |
| "website" or "redesign" | /Projects/WebsiteRedesign/_context.md |

When you mention "Cryo" in a conversation, Claude Code reads your routing table and loads the Cryo context file. You don't have to tell it. It just knows.

Testing Your Setup

Open Claude Code. Start a conversation. Type: "What clients do I work with?"

If your setup works, Claude responds with specific client names from your context files. No guessing. No "I don't have that information."

If it doesn't work, check three things:

1. Is your CLAUDE.md file in the vault root?
2. Are file paths in your routing table correct?
3. Did you use exact markdown formatting (double colons, proper headers)?

What You Can Do with This System

Once your AI knowledge base setup is complete, you can:

• Ask for client-specific content without re-explaining brand voice
• Generate proposals that include your actual pricing and services
• Get project updates that reference real deadlines and deliverables
• Request code that follows your actual tech stack
• Draft emails in your voice without style guidelines every time

Your AI stops being a generic tool. It becomes a team member who knows your business.

Maintenance Takes 5 Minutes Per Week

When you land a new client, add them to your client context file. When a project wraps, archive its context file. When your pricing changes, update your CLAUDE.md.

That's it.

The system doesn't require daily maintenance because it's file-based. Update the file, the AI sees it next session. No syncing, no database updates, no API calls.

Common Mistakes in AI Knowledge Base Setup

Using too many files. More files don't mean better context. Start with one CLAUDE.md file and 3-5 domain context files. Add more only when you're certain you need them.

Writing for humans instead of AI. Your context files aren't documentation. They're instructions. Write in second person ("You work with four clients...") not third person ("Victor works with...").

Including outdated information. Stale context is worse than no context. If a client ended six months ago, remove them. If your pricing changed, update it immediately.

Not testing changes. Every time you edit a context file, start a conversation and verify the AI reads the new information correctly.

Why This Beats ChatGPT Custom Instructions

ChatGPT lets you add custom instructions. 1,500 characters max. That's three short paragraphs.

A CLAUDE.md file can be 3,000+ words. Plus domain context files. Plus routing logic.

ChatGPT custom instructions are static. Change them once, they apply to every conversation. You can't have different context for different projects.

File-based context is modular. Mention a keyword, load that domain's context. Switch topics, load different context. One AI, infinite configurations.

ChatGPT uploads let you attach documents to conversations. Those documents expire when the conversation ends. File-based context persists forever.