Knowledge Engine

Universal research and knowledge layer for Hermes agents. Modular Skill Pack that orchestrates source-grounded research across pluggable knowledge providers.

What It Does

Decomposes questions → gathers evidence from multiple providers → validates claims → detects contradictions → synthesizes structured actionable output.

Works for: coding, API research, documentation, marketing, SEO, product, business, career, learning, strategy, deep research.

Architecture

User Query
    ↓
[Orchestrator] ─── Intent Detection → Mode Selection
    ↓
[Planner] ─── Decompose into research questions
    ↓
[Provider Selector] ─── Route to best knowledge source
    ↓
[Research Loop] ─── Iterative decomposed questioning
    ↓
[Gap Detector] ─── Find missing information (balanced+)
    ↓
[Evidence Validator] ─── Verify quality, detect fabrication
    ↓
[Contradiction Checker] ─── Cross-reference validation (deep+)
    ↓
[Synthesizer] ─── Evidence → structured analysis
    ↓
[Self Review] ─── Final quality gate
    ↓
[Structured Output] ─── Contract-compliant response

Execution Modes

Mode	Research Loops	Gap Detection	Contradiction Check	Self Review	Use When
fast	1	✗	✗	✗	Simple factual questions
balanced	2	✓	✗	✓	Standard research (default)
deep	3	✓	✓	✓	Complex analysis
autonomous	unlimited	✓	✓	✓	"Keep going until confident"

Knowledge Providers

Provider	Best For	Status
NotebookLM	User-uploaded documents, domain-specific knowledge	Ready (needs auth setup)
GitHub Docs	Open-source documentation, API references	Ready
Local Markdown	Project docs, Obsidian vault, internal KB	Ready
PDF Library	Research papers, technical specs, manuals	Ready (needs pymupdf)
Web Search	General knowledge (fallback)	Always available

Directory Structure

knowledge-engine/
├── SKILL.md                              # Orchestrator (entry point)
├── README.md                             # This file
├── config/
│   ├── execution-modes.yaml              # fast/balanced/deep/autonomous
│   ├── evidence-policy.yaml              # Evidence quality rules
│   └── output-contract.yaml              # Required output sections
├── skills/
│   ├── ke-planner/SKILL.md               # Query decomposition
│   ├── ke-notebook-selector/SKILL.md     # Provider routing
│   ├── ke-research-loop/SKILL.md         # Iterative questioning
│   ├── ke-gap-detector/SKILL.md          # Coverage analysis
│   ├── ke-evidence-validator/SKILL.md    # Quality validation
│   ├── ke-contradiction-checker/SKILL.md # Conflict detection
│   ├── ke-synthesizer/SKILL.md           # Evidence → analysis
│   └── ke-self-review/SKILL.md           # Final quality gate
├── providers/
│   ├── ke-notebooklm/SKILL.md            # NotebookLM browser automation
│   ├── ke-github-docs/SKILL.md           # GitHub repo documentation
│   ├── ke-local-markdown/SKILL.md        # Local filesystem docs
│   └── ke-pdf-library/SKILL.md           # PDF document extraction
└── scripts/
    ├── auth_manager.py                   # NotebookLM authentication
    ├── notebook_manager.py               # Notebook library management
    └── ask_question.py                   # NotebookLM query engine

Quick Start

1. Load the skill

/skill knowledge-engine

2. Use it

# Fast mode — quick API lookup
"How does the fetch API signal option work?"

# Balanced mode — standard research
"Compare REST vs GraphQL for our e-commerce API"

# Deep mode — thorough investigation
"Deep dive into our authentication system security"

# Autonomous mode — keep going
"Research everything about migrating to microservices. Keep going until confident."

3. With NotebookLM (optional)

# First-time auth
python3 scripts/auth_manager.py --setup

# Add a notebook
python3 scripts/notebook_manager.py --add "https://notebooklm.google.com/notebook/XXXXX" \
  --name "My Docs" --tags "api, react"

# Now queries auto-route to NotebookLM
"What does my React docs say about hooks?"

Design Principles

1. Knowledge ≠ Reasoning — Providers supply evidence. Hermes reasons over it.
2. Evidence before reasoning — Research completes before analysis begins.
3. No fabrication — Every claim traces to a source. No exceptions.
4. Single responsibility — Each skill does ONE thing well.
5. Orchestrator controls flow — No sub-skill invokes itself or others.
6. Provider abstraction — Orchestrator never hardcodes provider logic.
7. Mode-aware execution — Complexity scales with need.

Key Differences from Reference (PleasePrompto)

Aspect	PleasePrompto	Knowledge Engine
Architecture	Monolith (1 SKILL.md + 3 scripts)	Modular (13 SKILL.md + 3 configs + 3 scripts)
Providers	NotebookLM only	4 providers + web_search fallback
Modes	None	fast / balanced / deep / autonomous
Evidence policy	Implicit	Explicit with quality tiers
Gap detection	None	Dedicated skill with coverage scoring
Contradiction check	None	Dedicated skill with 4 contradiction types
Self review	None	7-check quality gate
Output contract	Ad-hoc	10-section structured contract
Fabrication prevention	Trust-based	Active detection with rejection

File Stats

• 13 SKILL.md files
• 3 YAML config files
• 3 Python scripts
• 19 total files
• ~104 KB total

License

MIT