Knowledge Base

Noah's persistent memory. A structured directory of Markdown files that Noah reads for context about your environment and writes to when it learns something new — so it never forgets your printer model, your VPN setup, or that DNS fix from last month.

What is the Knowledge Base?

The Knowledge Base is a directory of plain Markdown files stored on your device. It serves two purposes:

  1. Noah reads from it to understand your environment — what devices you have, how your network is configured, what issues you've resolved before.
  2. Noah writes to it to remember things — when you tell Noah about a new printer, a resolved issue, or a preference, it saves that information for next time.

Every file is a simple .md (Markdown) file. You can read, edit, or create them yourself with any text editor. Noah organizes them into categories using subdirectories.

💡
Think of the Knowledge Base as Noah's notebook. The more it knows about your environment, the better and faster it can help you. Over time, Noah builds up a detailed picture of your devices, your network, your preferences, and what's gone wrong before.

Categories

Knowledge files are organized into subdirectories by category. Each category has a specific purpose:

devices/
Device inventory. Printer models, server specs, hardware notes, peripheral details. When you tell Noah "the office printer is an HP LaserJet M404n," it saves a file here.
issues/
Past resolved issues and their solutions. When Noah helps you fix a problem, it can save the diagnosis and solution so it has a head start if the same issue comes back.
network/
Network configuration. WiFi details, DNS servers, VPN info, subnet layouts, proxy settings. Anything Noah needs to know about how your network is set up.
playbooks/
Diagnostic and procedural protocols. A special category — playbooks can be activated for structured execution, not just referenced. See Playbooks for full details.
preferences/
User preferences and app settings. Communication style, notification preferences, default behaviors. Noah stores your preferences here so it can tailor its responses.
software/
Installed apps, licenses, and configurations. Notes about software installations, license keys, configuration details, and version requirements.

You can also create custom subcategories by adding new subdirectories. Noah will discover them automatically.

How Noah uses knowledge

Noah's relationship with the Knowledge Base is woven into every conversation. Here's what happens behind the scenes:

Table of contents

When a conversation starts, Noah's system prompt includes a table of contents listing every knowledge file — the filename, category, and a brief description. This lets Noah know what information is available without loading every file into memory.

LLM tools

Noah has three tools for interacting with the Knowledge Base:

ToolDescription
knowledge_search Search knowledge files by keyword. Matches both filenames and file content. Supports wildcards and category-scoped search.
knowledge_read Read the full content of a specific knowledge file by path. Used when Noah needs detailed information from a file it found in the table of contents or via search.
write_knowledge Create or update a knowledge file. Noah picks the right category, generates a slugified filename, and writes Markdown content with optional YAML frontmatter.

Typical uses

  • Remembering device details — "Remember that the conference room printer is an HP LaserJet M404n on 192.168.1.50"
  • Tracking resolved issues — After fixing a DNS problem, Noah saves the root cause and solution for future reference
  • Storing user preferences — "I prefer you explain things technically, not in simple terms"
  • Recording network info — "Our office WiFi is 'CorpNet-5G' and the DNS servers are 1.1.1.1 and 8.8.8.8"
  • Software configuration — "We use GlobalProtect for VPN, the portal is vpn.example.com"
ℹ️
Noah doesn't load every knowledge file into every conversation. It reads the table of contents, then selectively searches and reads only the files relevant to the current problem. This keeps conversations fast and focused.

Creating knowledge files

There are two ways to add knowledge: ask Noah, or create files manually.

Ask Noah

The easiest way. Just tell Noah something you want it to remember:

"Remember that the office printer is an HP LaserJet M404n"
"Our WiFi password for the guest network is on the whiteboard in Room 3"
"The VPN portal address is vpn.example.com"
"John prefers dark mode and technical explanations"

Noah will use the write_knowledge tool to create a Markdown file in the appropriate category. It picks the category, generates a clean filename, and writes structured content.

Create files manually

You can also drop .md files directly into the knowledge directory. Noah discovers new files automatically — no restart required.

Filename conventions

  • Filenames are slugified: lowercase, hyphens instead of spaces, no special characters
  • Examples: hp-laserjet-m404n.md, office-wifi-config.md, dns-fix-march-2026.md
  • The filename (without .md) serves as the file's identifier
  • Keep names descriptive but concise — they appear in the table of contents
💡
You can ask Noah to create knowledge about anything — not just IT topics. Want it to remember your team's Zoom room link, the building's WiFi password, or which monitor port the projector uses? Just tell it.

Searching knowledge

Noah searches the Knowledge Base automatically when it needs context. You can also ask it to search directly.

Automatic search

When you describe a problem, Noah checks its table of contents for relevant files. If it sees a match, it reads the file for context before responding. For example, if you say "the printer is jammed again," Noah will look for files in devices/ that mention printers.

Direct search

Ask Noah what it knows:

"What do you know about our printers?"
"Search your knowledge for VPN configuration"
"Do you have any notes about the DNS issue from last week?"

How search works

  • Keyword matching — Searches both filenames and file content for matching terms
  • Wildcard support — Use * to list all files in a category or across the entire knowledge base
  • Category scoping — Search can be restricted to a specific category or subdirectory (e.g., only search within devices/)
  • Results include previews — Search returns file paths and content snippets so Noah can decide which files to read in full

File format

Knowledge files are plain Markdown (.md) with optional YAML frontmatter. There's no strict schema — Noah is flexible about what it reads and writes.

Basic example

devices/hp-laserjet-m404n.md
# HP LaserJet M404n

Office printer on the 2nd floor, next to the kitchen.

- **IP Address:** 192.168.1.50
- **Model:** HP LaserJet Pro M404n
- **Serial:** VNB3K12345
- **Toner:** HP 58A (CF258A)
- **Connection:** Ethernet, shared via CUPS

## Notes
- Paper tray holds Letter size only
- Duplex printing enabled by default
- Last serviced: January 2026

With YAML frontmatter

network/office-wifi.md
---
title: Office WiFi Configuration
created: 2026-02-15
updated: 2026-03-10
---

# Office WiFi Configuration

## Networks
- **CorpNet-5G** — Main employee network (WPA2-Enterprise)
- **CorpGuest** — Guest network (WPA2-PSK, password on lobby whiteboard)

## DNS Servers
- Primary: 1.1.1.1 (Cloudflare)
- Secondary: 8.8.8.8 (Google)

## Notes
- RADIUS auth through Azure AD
- Guest network has 50 Mbps cap
- VPN required for file server access from guest network

Format rules

  • File extension: Must be .md
  • Frontmatter: Optional. YAML between --- markers at the top of the file. Useful for metadata like creation date or tags.
  • Title: The first # Heading in the file is used as the display title in the table of contents
  • Content: Standard Markdown — headings, lists, code blocks, links, and so on
  • Security: Path traversal protection prevents files from being read or written outside the knowledge directory
⚠️
Path traversal protection. Noah enforces strict path validation. Files cannot be read from or written to locations outside the knowledge directory. Paths like ../../etc/passwd are rejected.

Knowledge and playbooks

Playbooks live inside the Knowledge Base at knowledge/playbooks/, but they are a special category with additional capabilities.

What makes playbooks special

FeatureRegular knowledgePlaybooks
Searchable Yes Yes
Readable Yes Yes
Writable Yes Yes
Activatable No Yes — loaded into context for structured execution
Source taxonomy No Yes — local bundled fleet
Precedence rules No Yes — fleet > bundled > local
Progress tracking No Yes — step-by-step UI for procedural playbooks
Auto-heal integration No Yes — triggered by failing health checks

For everything about playbooks — how to create them, frontmatter fields, source precedence, fleet delivery, and auto-heal — see the Playbooks documentation.

ℹ️
Regular knowledge files and playbooks coexist in the same directory structure. You can browse all of them from the Knowledge tab in the Noah sidebar.

Data locations

The Knowledge Base is stored inside Noah's application data directory. The exact path depends on your operating system:

macOS ~/Library/Application Support/app.onnoah.desktop/knowledge/
💻
Windows %APPDATA%\app.onnoah.desktop\knowledge\
🐧
Linux ~/.local/share/app.onnoah.desktop/knowledge/

Directory structure

knowledge/
  devices/
    hp-laserjet-m404n.md
    conference-room-display.md
  issues/
    dns-resolution-failure-march-2026.md
    outlook-sync-stuck.md
  network/
    office-wifi.md
    vpn-config.md
  playbooks/
    network-diagnostics.md
    printer-repair.md
    setup-ssh-key.md
    ...
  preferences/
    communication-style.md
  software/
    globalprotect-vpn.md
    slack-enterprise.md
💡
You can open the knowledge directory in Finder/Explorer at any time. The files are plain Markdown — feel free to edit them, reorganize them, or back them up. Noah will pick up any changes automatically.