Appearance
The Tools: What Each One Does
Your personal knowledge base runs on five tools working together. None of them is magic on its own — the power comes from how they connect.
1. The LLM (Claude)
The large language model is the reasoning engine. It reads text, thinks about it, and writes text back.
What it does:
- Reads your messages and any context loaded into the conversation
- Reasons about what you need — connecting facts, spotting patterns, making inferences
- Writes responses, files, meeting notes, and structured data
What it does NOT do:
- Remember anything between conversations. Every session starts fresh.
- Access your files directly. It can only see what the harness loads.
- Browse the internet on its own. It needs tools to reach external systems.
Why this matters for your KB: Because the LLM has no memory, your knowledge base IS the memory. Every file Claude writes today becomes context it can read tomorrow. The KB is not a nice-to-have — it is the persistence layer.
Could you swap it? Yes. The LLM could be GPT, Gemini, Llama, or whatever comes next. The knowledge base files are plain Markdown. The skills are plain Markdown. The frontmatter is plain YAML. Nothing locks you to one model. What matters is the pattern: structured files + reasoning engine + tool access.
2. The Harness (Claude Code)
If the LLM is the brain, Claude Code is the hands.
Claude Code is the orchestration layer that sits between you and the LLM. It manages the conversation, loads context, calls tools, and writes files. Without it, the LLM is just a chatbot. With it, the LLM becomes an agent that can actually do things.
What the harness does:
📋
Reads your config
CLAUDE.md tells it your role, preferences, and rules
🔍
Searches your files
Finds the right People profiles, meeting notes, and decisions
🔌
Calls external tools
Search, project tracker, calendar, chat: on your behalf, with your permissions
📝
Writes files
Creates meeting notes, updates People profiles, edits your Work Board
🧩
Manages skills
Matches your request to the right skill and follows its instructions
Multiple interfaces, same harness:
You can use Claude Code through several interfaces — they all connect to the same engine:
| Interface | Best for |
|---|---|
| Terminal (CLI) | Power users, scripting, automation |
| VS Code extension | Working alongside your KB files |
| Desktop app | Standalone conversations |
| Web app | Quick access from any browser |
The interface you choose doesn't matter much. What matters is that CLAUDE.md, your skills, and your KB files are accessible from whichever one you use. Most KB users settle on the VS Code extension because it puts the file browser and AI chat side by side.
3. The IDE (VS Code)
VS Code is a free code editor, but you are not using it to write code. You are using it as your workspace — a place to browse files, search content, and talk to Claude in the same window.
Why VS Code for a knowledge base?
- File browser on the left shows your entire KB structure
- Editor in the center lets you read and edit any file
- Claude Code panel on the right (or bottom) gives you AI chat
- Search across all files with Ctrl/Cmd+Shift+F
- Split view to compare two files side by side
You open your KB folder in VS Code, and everything is right there. When Claude writes a meeting note, you see it appear in the file browser. When you want to edit a People profile, you click it open. When you want to ask Claude something, you type in the panel.
You do not need to know how to code. VS Code is just a really good file manager with a built-in AI assistant.
4. The Viewer (Obsidian)
Obsidian reads the same Markdown files that Claude writes. It is not a replacement for VS Code — it is a companion that gives you a different view of the same data.
VS Code vs Obsidian:
| Feature | VS Code | Obsidian |
|---|---|---|
| Browse files | Yes | Yes |
| Search content | Yes | Yes |
| Backlinks (who links here?) | No | Yes |
| Hover preview (see linked file) | No | Yes |
| Graph view (visual connections) | No | Yes |
| Polished reading experience | Basic | Yes |
| Talk to Claude | Yes | No |
| Edit files | Yes | Yes |
The key insight: Obsidian is where you read and explore. VS Code is where you work and talk to Claude. Both point at the same folder on your computer.
Local-only, no cloud sync. Obsidian reads files from your local disk. There is no cloud service, no subscription required, no data leaving your machine. Your files are plain Markdown — if Obsidian disappeared tomorrow, every other text editor on earth can read them.
When to use Obsidian:
- You want to see who is connected to whom (graph view)
- You want to click through links between meetings, people, and decisions
- You want a clean reading experience for longer documents
- You want to see "what links to this file?" (backlinks)
When to use VS Code:
- You want to talk to Claude
- You want to process a meeting, run a skill, or update your work board
- You want to do bulk edits or reorganize files
5. The Tools (MCPs)
MCP stands for Model Context Protocol. Think of it as USB for AI — a standard way to plug external tools into Claude Code.
Without MCPs, Claude can only read and write local files. With MCPs, Claude can reach into your company's systems: search across documents, read project tickets, check calendars, browse chat history, query databases.
How it works:
+-----------+
| Search |
| Tool |
+-----+-----+
|
+--------+ +------+------+ +----------+
| Jira +-----+ Claude Code +-----+Confluence|
+--------+ +------+------+ +----------+
|
+-----------+-----------+
| | |
+-----+---+ +----+----+ +----+-----+
| Calendar| | Slack | |Snowflake |
+---------+ +---------+ +----------+Claude Code sits at the center. Each MCP connection gives it access to one system. You control which MCPs are enabled and what permissions they have.
Common MCP connections:
| Tool | What Claude can do with it |
|---|---|
| Search tool | Find documents, wiki pages, and past conversations across your organization |
| Jira | Read tickets, check sprint boards, look up project status |
| Confluence | Read wiki pages, find documentation, check team spaces |
| Calendar | See your schedule, find meeting details, check attendee lists |
| Slack | Read channel history, search messages, find threaded discussions |
| Snowflake | Query data warehouses, pull metrics, check dashboards |
Why this matters for your KB:
When Claude processes a meeting note, it can cross-reference against your project tracker to see which tickets were discussed. When it writes a People profile for [[Elaine-Benes]], it can pull context from chat messages and wiki pages. When you ask "what's the status of Import-Export?", it can check the actual ticket board instead of guessing.
The MCPs are optional. Your KB works without them — Claude just reads and writes local files. But with them, extraction gets richer and answers get more grounded.
Setting up MCPs:
MCPs are configured in your Claude Code settings. Each one typically needs:
- A server endpoint (provided by your organization or installed locally)
- Authentication (usually your existing credentials)
- Permissions (what the tool is allowed to do)
Your organization may provide pre-configured MCP servers, or you can set up open-source ones yourself. The MCP protocol is an open standard — any tool that speaks it can plug into Claude Code.
How They Work Together
Here is a typical flow when you say "process my meeting":
- You type the request in VS Code (or terminal, or desktop app)
- Claude Code (harness) loads your CLAUDE.md config and matches the "process-meeting" skill
- Claude (LLM) reads the skill instructions and your transcript
- Claude Code calls MCPs to look up attendees in your search tool and check related tickets in Jira
- Claude (LLM) writes the structured meeting note with extracted signals
- Claude Code saves the file to your KB folder
- You review it in VS Code or read it later in Obsidian
No single tool does everything. The LLM reasons. The harness orchestrates. The IDE gives you a workspace. The viewer gives you navigation. The MCPs give you reach. Together, they make a system that builds knowledge while you work.