VIEW THIS AS

Auto mode follows the Route Engine until you choose a viewpoint.

YOU ARE HERE

ROUTE CHECK

CONNECTED TO

WHAT NEXT

Use the canonical route for this room, or HELP if you are unsure.

How to Build a Knowledge Base With Super Intelligence | Sources, RAG, Retrieval and AI Knowledge Systems

Three secondary students review open books and notes together in a classroom.
Secondary students organising books and notes into a knowledge system

How do you build a knowledge base with Super Intelligence that remains useful instead of becoming a folder full of summaries? You define what the knowledge base is for, establish canonical source records, create structured notes with provenance, manage versions and contradictions, then design retrieval around real questions.

SI can accelerate knowledge-base work because it can extract metadata, summarise documents, tag concepts, build cross-links and answer questions across stored material. But a weak knowledge base simply accumulates generated text. Over time, old facts, duplicate notes and unsupported syntheses compete with current source material.

This eduKateSG guide completes the first half of Stage 3 in the How to Learn Super Intelligence Quickly curriculum after How to Compare Multiple Sources With Super Intelligence. It focuses on source registry, canonical notes, retrieval, versioning, provenance, update rules and maintainable SI knowledge systems.

Terminology: SI is our editorial term for practical contemporary AI learning. A knowledge base is a maintained information system; it should preserve the sources and state needed to verify important answers, not merely store generated prose.


The First Principle: A Knowledge Base Exists to Answer Future Questions

Do not build a knowledge base because storage is available. Build it because future work repeatedly needs certain facts, definitions, sources, decisions or procedures.

Start with user questions: What will people need to know? What decisions should the knowledge support? What information changes often? What must be traceable to a source?

The answers determine what belongs in the system and what can remain outside it.

Knowledge Base Versus Archive

An archive preserves material. A knowledge base organises material for retrieval and use. The same system can do both, but the functions are different.

An archive may keep every historical document. The active knowledge base may expose only current authoritative sources plus selected history.

Confusing archive and active knowledge creates stale-answer risk.

Knowledge Base Versus Notes Folder

A notes folder stores documents. A knowledge base adds structure: metadata, source identity, canonical status, relationships, definitions and update rules.

The goal is not to eliminate folders. It is to make important information discoverable and interpretable.

SI can help transform a folder into structured knowledge, but the user defines the information architecture.

Step 1 — Define the Knowledge Domain

Choose a bounded domain: a course, research project, company process, technical system, publication series or personal learning topic.

A knowledge base called “everything I know” becomes difficult to govern. Boundaries improve tagging, source hierarchy and retrieval.

Domains can later connect through explicit cross-links.

Step 2 — Define the Users

Different users need different views. Students may need definitions and examples. Researchers need source provenance and methods. Operators need procedures and current state.

The same underlying knowledge can support several presentation layers, but user needs determine what fields matter.

Receiver-centred design prevents the knowledge base from becoming an abstract taxonomy project.

Step 3 — Define the Questions

List twenty questions the knowledge base should answer. These questions become retrieval tests and expose missing structure.

Examples: What is the current policy? Which source owns this definition? What changed since version 2? Which evidence supports this claim? What is the next step in this workflow?

A knowledge base is useful when real questions retrieve reliable answers.

Step 4 — Build a Source Registry

Every important source should have a record containing title, type, owner, date, version, location, authority, status and scope.

Status might be Current, Historical, Draft, Superseded or Rejected.

The source registry separates document identity from the notes derived from it.

Step 5 — Define Canonical Sources

For recurring facts, decide which source owns the truth. An official policy page may own the deadline; a repository may own code; a glossary may own terminology.

Canonical ownership prevents two old summaries from competing with the current source.

When the canonical source changes, downstream notes can be marked for review.

Step 6 — Create Structured Source Notes

A source note should capture what the source contributes to the knowledge base, not merely restate every paragraph.

Fields can include Summary, Key Claims, Definitions, Evidence, Limitations, Source Locators, Related Concepts and Update Sensitivity.

Keep source-derived content separate from your synthesis.

Step 7 — Create Claim Records

For high-value research bases, create claim-level records connecting a claim to supporting and contradicting sources.

A claim record can contain Claim, Scope, Supporting Sources, Conflicting Sources, Evidence Weight, Current Status and Review Trigger.

This turns the knowledge base into an evidence system rather than a document library.

Step 8 — Create Definition Records

Definitions deserve their own objects when terminology matters. Record canonical term, definition, source, aliases and related terms.

If sources use the same word differently, create source-specific definitions or a crosswalk rather than forcing one meaning.

Stable terminology improves both human retrieval and machine retrieval.

Step 9 — Create Decision Records

Projects and organisations need decision knowledge as well as factual knowledge.

A decision record can include Question, Decision, Owner, Date, Evidence, Reason, Superseded Decision and Review Condition.

This prevents long conversations from reopening settled choices without new evidence.

Step 10 — Create Procedure Records

Operational knowledge should describe inputs, steps, checks, stop conditions and outputs.

A procedure is different from a conceptual article. Users need to know what to do next and what counts as failure.

SI can help convert repeated conversations into workflow cards.

Step 11 — Create Relationship Links

Knowledge becomes more useful when records connect: definition to article, claim to evidence, procedure to policy, decision to source, concept to example.

Use relationships that answer real navigation questions. Avoid creating a graph merely because graph structure is fashionable.

Every link should have a semantic purpose.

Step 12 — Add Metadata

Metadata supports filtering and retrieval. Useful fields include topic, source type, date, status, owner, geography, population and confidentiality.

Keep the metadata vocabulary controlled enough that tags do not fragment into near-synonyms.

A small consistent taxonomy is often better than hundreds of ad hoc tags.

Step 13 — Add Versioning

Knowledge changes. Record version or update date for sources, procedures and schemas where changes matter.

Do not overwrite historical decisions or definitions without preserving enough history to understand change.

Versioning turns updates into controlled evolution rather than silent replacement.

Step 14 — Define Freshness Rules

Some knowledge is stable; some decays quickly. Assign refresh expectations according to volatility.

A mathematical definition may remain stable. Product pricing, law, software features and organisational roles may need frequent checks.

Freshness rules help SI know when retrieval should trigger current-source verification.

Step 15 — Define Conflict Handling

A knowledge base must represent disagreement. Add Conflict or Disputed status instead of forcing one value.

Record the sources and what evidence would resolve the conflict.

Hidden contradiction is more dangerous than visible uncertainty.

Step 16 — Define Unknown Handling

The knowledge base should be able to say “unknown”, “not specified” or “not yet researched”.

Do not populate empty fields with generated guesses merely to make the database look complete.

An explicit unknown is useful knowledge about the state of the system.

Step 17 — Design Retrieval

Retrieval should answer user questions using the most relevant current records. Keywords, semantic search, filters and relationship links can all contribute.

The retrieval layer should prefer current canonical sources where the question asks about current state.

For historical questions, the same system may intentionally retrieve superseded material.

Retrieval-Augmented Generation

Retrieval-augmented generation, often shortened to RAG, combines retrieved knowledge with model generation. The model uses selected records as context for the answer.

RAG quality depends heavily on source quality, chunking, metadata and retrieval relevance. A powerful model cannot fix a knowledge base that retrieves the wrong source.

Treat retrieval as an evidence-selection layer, not magic memory.

Chunking Knowledge

Long documents may be split into chunks for retrieval. Chunk boundaries should preserve meaning where possible: sections, paragraphs or semantic units.

Chunks need source identity and locators. A retrieved paragraph without its document and page can become difficult to verify.

Chunk overlap can help context but can also create duplication.

Chunk Size Trade-Offs

Small chunks improve specificity but can lose context. Large chunks preserve context but may retrieve too much irrelevant material.

Test chunk sizes against the actual questions users ask.

The correct chunking strategy is empirical and domain-specific.

Metadata-Aware Retrieval

Metadata can restrict search to current sources, one jurisdiction, one product version or one content type.

This is often stronger than relying only on semantic similarity.

Example: current Singapore policy questions should filter geography and current status before semantic ranking.

Hybrid Retrieval

Hybrid retrieval combines lexical matching with semantic similarity or structured filters.

Exact terms are useful for names, codes and quotations; semantic retrieval helps when wording differs.

A maintainable knowledge base supports both rather than forcing every query through one mechanism.

Retrieval Validation

Before trusting generated answers, inspect what records were retrieved. Were they current, authoritative and directly relevant?

A wrong answer may originate in retrieval rather than generation.

Store retrieval traces for important workflows when practical.

Answer Provenance

A knowledge-base answer should expose which source records support the important claims.

Provenance enables verification and helps users distinguish source-derived information from model synthesis.

The more consequential the claim, the more visible the provenance should be.

Canonical Answers Versus Generated Answers

Some questions deserve a maintained canonical answer rather than fresh generation every time. Examples include official definitions, contact procedures or safety instructions.

Use generated answers for synthesis where flexibility helps. Use canonical text when consistency and authority are more important.

The knowledge base can store both and route queries accordingly.

Knowledge Base Taxonomy

Taxonomy is the controlled classification structure. It can include subjects, content types, roles, states and relationships.

Keep taxonomy aligned with user questions. Too many levels create maintenance burden and retrieval friction.

Review tags that are rarely used or overlap heavily.

Ontology Versus Taxonomy

A taxonomy mainly classifies. An ontology describes entities and relationships more formally.

You do not need a formal ontology for every knowledge base. Use richer relationships when the domain genuinely benefits from machine-readable semantics.

Complexity should earn its place by improving retrieval, reasoning or interoperability.

Knowledge Graphs

A knowledge graph represents entities and relationships. It can connect people, concepts, documents, decisions and systems.

Graphs are useful when relationship queries matter: which sources support this claim, which procedures depend on this policy, which concepts share a prerequisite?

A graph does not fix poor source quality. It makes relationships explicit.

Knowledge Base Permissions

Not every user should see every record. Apply access controls according to sensitivity and role.

Separate public, internal, confidential and restricted material where necessary.

Retrieval should respect permissions before generation begins.

Sensitive Knowledge

Personal, legal, financial and proprietary information requires stronger governance. Minimise stored sensitive data and use approved systems.

Do not create broad embeddings or indexes of confidential material without understanding provider and organisational controls.

Security architecture belongs before convenience.

Knowledge Base Ownership

Assign ownership for domains, source registries and critical procedures. Without owners, stale information remains active because nobody knows who should update it.

Ownership can be lightweight in a personal system: you are the owner and a monthly review is enough.

Team systems need clearer responsibility.

Knowledge Base Review Cycles

Review by volatility and consequence. Current operations may need weekly review; stable theory can be reviewed far less often.

Use update triggers when a source changes, product version releases, policy updates or a decision is superseded.

Scheduled and event-driven maintenance can coexist.

Knowledge Base Quality Metrics

Useful qualitative metrics include retrieval relevance, source freshness, duplicate rate, unresolved conflicts, answer traceability and user success.

Do not optimise only for number of documents or notes. Volume is not knowledge quality.

A smaller clean base can outperform a huge unmanaged archive.

Duplicate Detection

Duplicates arise when the same document is uploaded twice, when notes restate the same claim or when several pages repeat one source.

Use source identifiers and semantic similarity to detect duplicates, but review before merging records that only appear similar.

Duplicate control reduces retrieval noise.

Canonicalisation

When several notes describe the same concept, designate one canonical record and link variants or historical versions to it.

Canonicalisation prevents retrieval from presenting contradictory outdated definitions.

Do not destroy history; mark status and relationship.

Stale Knowledge

A stale record is not necessarily false historically. The problem is using it as current.

Mark stale or superseded status. Exclude stale records from default current retrieval where appropriate.

Historical queries can still access them intentionally.

Contradiction Detection

SI can help scan a knowledge base for incompatible claims about the same entity, date or definition.

Treat detected contradictions as review candidates, not automatic errors. The sources may refer to different periods or scopes.

Resolve through provenance and source authority.

Knowledge Base Search Logs

Search logs can reveal what users ask and where retrieval fails. Repeated unanswered questions indicate missing knowledge or poor indexing.

Use logs carefully with privacy in mind.

Question frequency can guide maintenance priorities.

Feedback Loops

Allow users to flag wrong, stale or unhelpful answers. Link feedback to the underlying source record or retrieval path.

Repair the knowledge system rather than only correcting one generated response.

Feedback turns everyday use into quality monitoring.

A Worked Example: Course Knowledge Base

Sources: syllabus, textbook chapters, teacher notes, assignment instructions and verified worked examples.

Canonical ownership: syllabus owns learning outcomes; assignment page owns deadlines; textbook owns definitions where specified.

Retrieval can answer “What should I practise next?” using current error records plus prerequisite relationships.

A Worked Example: Research Project Knowledge Base

Sources become records with methods, findings, limitations and claim links. A contradiction register tracks disagreements.

Research notes connect to the central question and evidence ledger.

The final report can be regenerated from the maintained evidence system without losing provenance.

A Worked Example: Publishing Knowledge Base

Track article title, canonical URL, keyword ownership, status, featured image family, internal links and content standards.

A hub can retrieve which articles are live and which are planned. Duplicate slugs are detected before publication.

The knowledge base becomes the operational memory of the publishing system.

A Worked Example: Software Project Knowledge Base

Store architecture decisions, API contracts, runbooks, known incidents, dependencies and version-specific documentation.

The repository remains authoritative for code. The knowledge base explains why the system is designed the way it is and how to operate it.

Retrieval should filter documentation by software version.

A Worked Example: Personal Knowledge Base

A personal system may store books, courses, projects and durable notes. Keep sources and your own synthesis separate.

Use tags and relationships based on future questions rather than collecting everything.

Periodically retire notes that no longer support any active or likely future use.

Knowledge Base Failure Mode 1 — Everything Goes In

The system becomes an archive with no quality control. Repair by defining domain, users and inclusion criteria.

Failure Mode 2 — Summaries Replace Sources

Generated notes become the only surviving representation. Repair by preserving source links and provenance.

Failure Mode 3 — No Canonical Owner

Several records compete for the same fact. Repair by source hierarchy and canonicalisation.

Failure Mode 4 — Stale Current Answers

Old records are retrieved for current questions. Repair with freshness status and metadata filtering.

Failure Mode 5 — Duplicate Noise

Retrieval returns many copies of the same evidence. Repair with deduplication and provenance clusters.

Failure Mode 6 — Unknowns Are Filled In

Generated answers invent missing knowledge. Repair with explicit Unknown state and source-grounded answering.

Failure Mode 7 — Contradictions Are Hidden

The system chooses one source silently. Repair with conflict representation and review workflow.

Failure Mode 8 — Tags Explode

Users create near-duplicate tags. Repair with controlled vocabulary and periodic cleanup.

Failure Mode 9 — Permission Leakage

Retrieval surfaces restricted knowledge to the wrong user. Repair at access-control and retrieval layers.

Failure Mode 10 — Knowledge Without Use

The base grows but does not answer real questions. Repair by returning to user needs and retrieval tests.

A Knowledge Base Design Checklist

  • Domain defined.
  • Users defined.
  • Question set defined.
  • Source registry exists.
  • Canonical source ownership exists.
  • Structured notes preserve provenance.
  • Claims and definitions are modelled where needed.
  • Versions and freshness are tracked.
  • Unknown and conflict states exist.
  • Retrieval is tested on real questions.
  • Permissions are enforced.
  • Feedback and maintenance loops exist.

A Practice Lab: Build a Ten-Source Knowledge Base

Choose one bounded topic and collect ten authorised sources. Create source records and one note per source.

Define five questions the base should answer. Test retrieval manually or with SI.

Record where the answers are missing, stale or ambiguous. Improve structure before adding more sources.

A Practice Lab: Canonicalise a Messy Notes Folder

Select twenty old notes. Group duplicates and near-duplicates. Choose one canonical note per concept and link the rest as historical or derivative.

Add source references to any note you plan to keep.

The goal is reduction and clarity, not migration of every old note.

A Practice Lab: Build a Conflict Register

Find three cases where sources disagree. Record competing claims, source scope and current resolution status.

Ask SI to propose why the disagreement may exist, then verify those explanations.

Keep unresolved cases visible.

A Practice Lab: Test Retrieval

Write ten questions without looking at the knowledge base. Retrieve answers using your current system.

Score qualitatively: relevant source retrieved, current source retrieved, answer supported, uncertainty handled.

Improve retrieval and metadata based on failures.

Frequently Asked Questions

Do I need a vector database?

Not necessarily. Small knowledge bases can work with folders, documents, databases or ordinary search. Add vector retrieval when semantic search solves a real problem.

What is RAG?

Retrieval-augmented generation supplies selected knowledge-base material to the model during generation. Its quality depends on retrieval and source quality as much as model capability.

Should I store AI summaries?

Yes when useful, but keep them linked to source records and distinguish generated synthesis from source content.

How often should I update the knowledge base?

According to volatility and consequence. Stable concepts need less frequent review than current product, policy or operational data.

Can a knowledge base replace source documents?

No. It can make sources easier to find and use, but important claims should remain traceable to the underlying evidence.

What comes next?

Continue with How to Learn a New Subject With Super Intelligence and the remaining Stage 3 articles in the complete SI learning hub.

The Knowledge Unit: The Smallest Piece Worth Maintaining

A useful knowledge base is easier to maintain when information is stored as meaningful units rather than as a pile of whole documents. A knowledge unit is a small record with one clear purpose: a definition, claim, source note, decision, procedure, example, exception or relationship.

Each unit should answer a future question. A definition unit answers “what does this term mean?” A decision unit answers “what did we choose and why?” A procedure unit answers “how do we do this?” A source note answers “what does this evidence establish?”

The unit should remain traceable to its source and should not contain several unrelated claims simply because they appeared in the same document. Smaller units make retrieval more precise, while larger units preserve context. Good knowledge architecture balances both.

Knowledge Unit Metadata

  • ID: stable identifier when the system needs durable references.
  • Type: definition, claim, decision, procedure, source note, example or another controlled category.
  • Title: short human-readable name.
  • Source: document, URL, record or human owner.
  • Date: publication, decision or verification date as appropriate.
  • Status: current, historical, proposed, superseded, conflict or unknown.
  • Scope: population, system, project or context in which the unit applies.
  • Owner: person or process responsible for review.
  • Review trigger: date or event that should cause revalidation.
  • Links: related units, dependencies, evidence or downstream procedures.

Metadata should exist only when it improves retrieval, maintenance or governance. A personal ten-note collection does not need enterprise-level fields. A team knowledge base supporting automated answers may need much stronger structure.

Canonical Knowledge: One Owner, Many Routes

A mature knowledge base separates the canonical owner of a fact or definition from the many places where that knowledge may be referenced. The canonical record owns the current statement; other notes, articles or workflows link back to it.

This reduces contradiction. If a deadline changes, update the canonical record once rather than editing a dozen copied summaries. If a definition evolves, downstream pages can continue to point to the current owner.

Canonical ownership is especially important when SI generates new summaries. Generated text should cite or reference canonical knowledge rather than silently becoming a new competing source.

Knowledge Duplication Versus Useful Redundancy

Not all repetition is harmful. A knowledge base may contain the same concept in a definition, worked example and procedure. That is useful redundancy because each record serves a different job.

Harmful duplication occurs when two records claim to be the current owner of the same fact and drift apart. The repair is canonicalisation: choose the owner, mark the other record as derived or historical and update links.

SI can help identify near-duplicates, but a human or governance rule should decide whether the records are actually equivalent.

A Knowledge Base Is an Answering System

The quality of a knowledge base should be evaluated through questions, not through storage volume. Build a representative question set: common questions, edge questions, missing-information questions and questions involving old versus current state.

For each question, test whether the system retrieves the right unit, exposes the correct source and avoids unrelated material. A large database that cannot reliably answer its intended questions is not a strong knowledge base.

This is why retrieval evaluation belongs inside knowledge-base design rather than being added after the archive is complete.

Retrieval Precision and Recall

Retrieval quality contains a trade-off. Precision asks whether the returned items are relevant. Recall asks whether important relevant items were missed. A system returning twenty documents may have high recall but poor precision; a system returning one narrow chunk may miss a crucial exception.

The optimal balance depends on the task. A quick FAQ needs high precision. A legal or research review may prefer broader recall followed by careful filtering.

Evaluate retrieval on the question set. Do not assume one similarity threshold or chunk size works for every domain.

Keyword, Semantic and Hybrid Retrieval

Keyword retrieval is strong when the user knows exact terminology, identifiers or names. Semantic retrieval is useful when the user expresses the concept in different words. Hybrid retrieval combines both.

For example, a query containing an exact policy code should benefit from keyword matching. A query asking “what happens when a learner cannot recover from repeated errors?” may benefit from semantic retrieval even if those words never appear in the source.

A robust knowledge system can route or combine methods instead of treating one retrieval technique as universally superior.

Chunking by Meaning Rather Than Arbitrary Length

Fixed-size chunks are easy to implement but can split a definition from its exception or a table from its heading. Semantic chunking attempts to keep coherent units together.

Useful chunk boundaries include headings, paragraphs, table sections, question–answer pairs and procedure steps. Preserve enough surrounding context that the retrieved unit can be interpreted correctly.

When a chunk is too large, retrieval becomes noisy. When it is too small, meaning becomes fragmented. Test chunking against real questions rather than choosing size only from technical limits.

Parent–Child Retrieval

One practical pattern stores small child chunks for precise retrieval while retaining a larger parent section for context. The system retrieves the narrow unit but can return the larger section to the model or reviewer.

This is useful for books, policies, manuals and long articles. A sentence may match the query, but the paragraph or section may be needed to preserve qualifications.

The pattern reduces the tension between precision and context without requiring every stored unit to be large.

Knowledge Base Answers Should Show Their Evidence

A knowledge-base answer becomes more trustworthy when it exposes the records used to produce it. For a human reader, that can mean source links, page references or named records. For software, it can mean provenance fields.

Do not let the generated answer become a dead end. The user should be able to return from the answer to the source unit and, when necessary, to the original document.

Evidence visibility also makes errors easier to diagnose: was the wrong item retrieved, or was the right item interpreted incorrectly?

Retrieval Failure Versus Generation Failure

These two failures require different repairs. Retrieval failure means the right knowledge never entered the context. Generation failure means the right knowledge was available but the answer misused it.

If retrieval fails, improve indexing, metadata, chunking, queries or source coverage. If generation fails, improve instructions, structure, constraints or validation.

Do not rewrite prompts endlessly when the system simply did not retrieve the relevant record.

Knowledge Base Conflict States

A knowledge base should be able to represent disagreement. Two current sources may conflict, or one team may propose a definition that has not been approved.

Use explicit states such as Conflict or Proposed. Store both claims with provenance. Define who can resolve the conflict and what evidence is required.

A generated answer can then say “two current records disagree” rather than manufacturing consensus.

Historical Knowledge Versus Current Knowledge

Old knowledge is not necessarily wrong. Historical rules, previous decisions and superseded definitions can be valuable for explaining how the system evolved.

The knowledge base should distinguish historical from current. Retrieval for a current-state question should prefer current records; historical analysis can deliberately include superseded units.

This temporal layer prevents old facts from re-entering operational answers accidentally.

The Freshness Envelope

Different knowledge decays at different rates. Mathematical definitions may remain stable for years. Prices, schedules, model capabilities, laws and internal project state may change quickly.

Assign review triggers according to decay risk. A stable concept may be event-triggered only. A current product specification may need periodic checks.

Freshness should be tied to consequence as well as probability. A rarely changing medical protocol may still deserve strong review because the cost of staleness is high.

Knowledge Approval Workflows

When many people contribute, distinguish Draft, Reviewed and Approved knowledge. SI-generated suggestions should not automatically enter the Approved layer.

The approval process can be lightweight for a small team: one reviewer confirms source and wording. Higher-consequence domains may require formal owners or expert review.

Retrieval for authoritative answers should prefer approved knowledge unless the query explicitly asks for proposals or drafts.

Knowledge Base Permissions by Layer

Some users may need to read approved knowledge but not drafts. Some tools may retrieve public documentation but should not access private records. Permission design should mirror the information architecture.

Avoid giving a retrieval system access to an entire organisation simply because the model can technically search it. Scope the knowledge domain to the task.

Permission-aware retrieval is essential when the knowledge base contains personal, confidential or regulated material.

A Knowledge Base for Students

A student knowledge base can contain syllabus map, concept definitions, worked examples, common errors, personal error log and spaced-retrieval questions.

The canonical source for syllabus requirements should remain the school or official curriculum. Personal notes can explain but should not silently redefine the requirement.

SI can retrieve the relevant prerequisite when the student fails a problem, then generate a fresh practice task. Independent attempts remain the check of learning.

A Knowledge Base for Teachers

A teacher knowledge base can contain learning objectives, misconceptions, examples, question banks, answer keys, lesson procedures and curriculum references.

Separate verified answer keys from generated draft questions. Record which resources have been reviewed and which remain experimental.

This allows SI to assist with lesson planning without treating every generated item as classroom-ready.

A Knowledge Base for Research

Research knowledge bases benefit from source records, claim records, method notes, population, date, limitation and relationship between claims.

A source can support several claim units. A claim can be supported or challenged by several sources. This network is more useful than storing one generic summary per paper.

When the project question changes, the same source can be retrieved through different claim relationships without rewriting the original notes.

A Knowledge Base for Publishing

Publishing systems can store canonical definitions, article ownership, keyword intent, approved internal links, media rules, fact sources and style constraints.

Before creating a new article, SI can query the registry for collision. Before publication, it can retrieve the current image family, word-count floor and hub route.

The knowledge base becomes a publishing control plane rather than a memory dump.

A Knowledge Base for Software

Software project knowledge can include architecture decisions, API contracts, schemas, known failures, runbooks, deployment procedures and repository references.

The code repository remains the authority for implementation. The knowledge base explains decisions, interfaces and procedures that are difficult to infer from code alone.

SI can retrieve the relevant architecture decision before proposing a change, reducing repeated rediscovery.

A Knowledge Base for Personal Life

A personal knowledge base should be selective. Useful records might include recurring procedures, project state, learning notes, household maintenance schedules and preferences that genuinely change repeated tasks.

Do not turn it into an indiscriminate biography. Minimise sensitive information and keep authoritative records in their proper systems.

The purpose is reducing reconstruction, not collecting everything about yourself.

Knowledge Base Evaluation Set

  • Five common questions.
  • Three boundary questions.
  • Two questions whose correct answer is Unknown.
  • Two questions involving superseded versus current knowledge.
  • Two questions requiring several records.
  • One permission-sensitive query.
  • One historical failure that previously returned the wrong answer.

Run the set after major changes to chunking, retrieval, model or source registry. Record whether the failure came from retrieval, generation or source quality.

Search Logs as Knowledge-Gap Sensors

Queries with no useful answer are valuable data. They reveal missing sources, poor terminology or user needs the current taxonomy does not represent.

Review failed and repeated searches. Add knowledge only when the gap reflects a legitimate future question. Do not fill the base with speculative content for every one-off query.

Search logs create a demand-driven maintenance loop.

User Feedback as a Knowledge Signal

When users correct an answer, record whether the problem was source, retrieval, interpretation or stale knowledge. Route the fix to the correct layer.

A correction should not simply become another free-text note. Update the canonical record or retrieval rules and add a regression question when the failure matters.

This turns feedback into system improvement rather than local patching.

Knowledge Retirement

Knowledge bases improve when obsolete units are retired deliberately. Mark records as superseded, archive them or remove them from current retrieval depending on the domain.

Preserve history when it explains decisions or supports auditability. Remove noise when it has no future use and creates retrieval confusion.

Retirement is as important as ingestion. A knowledge base that only grows will eventually become harder to trust.

Export and Portability

Important knowledge should not be trapped in one conversational tool. Keep canonical records in formats or systems that can be exported, inspected and migrated.

Portability reduces vendor dependence and supports long-term maintenance. A knowledge system built around sources, IDs, metadata and explicit relationships is easier to move than one built from opaque conversation memory.

The durable asset is the knowledge architecture, not one interface.

Backup and Recovery

If the knowledge base supports important operations, define how it is backed up and restored. Separate source documents, structured records and generated indexes so each layer can be recovered appropriately.

A retrieval index can often be rebuilt from canonical source records. The source registry and approved knowledge are harder to reconstruct if they are lost.

Recovery planning belongs in serious knowledge systems even when SI is only one component.

A Full Build Example: Ten-Source Research Knowledge Base

Start with ten sources around one research question. Create a source registry with date, type, population and role. Extract two to five claim units from each source with page or section references.

Create relationship links: supports, challenges, defines, updates or contextualises. Mark one source as canonical only where its authority justifies that role; do not force all claims to have one owner.

Build a question set. Test retrieval with exact terminology and paraphrases. For every wrong answer, identify whether the source was absent, the wrong claim was retrieved or the synthesis overreached.

After the test, remove duplicate notes, refine metadata and write one bounded synthesis. The knowledge base is now more than ten summaries: it is a navigable evidence system.

A Full Build Example: Publishing Control Knowledge Base

Create records for Series, Article, Search Intent, Canonical URL, Status, Word Floor, Image Family, Internal Links and Collision Rules. Each article has one canonical owner and can reference its hub.

When a new page is proposed, query by intent and slug before creation. If a page already exists, improve the canonical owner rather than creating a competing URL.

When an image rule changes, update the series record. Before publication, the workflow retrieves the current rule and verifies both featured and header media.

This knowledge base turns publishing standards into reusable operational context instead of relying on one conversation to remember everything.

The Knowledge Base Maturity Ladder

Level 1 — Organised sources

Files and notes are named, dated and findable. Duplicate chaos is reduced.

Level 2 — Structured knowledge

Definitions, claims, decisions and procedures are separated into reusable records with provenance.

Level 3 — Reliable retrieval

Representative questions retrieve the correct knowledge with useful precision and context.

Level 4 — Governed knowledge

Freshness, permissions, canonical ownership, conflicts and approval states are maintained.

Level 5 — Operational knowledge system

SI can retrieve, synthesise and support workflows while users can trace answers back to maintained sources and recover from failures.

The ladder is descriptive, not a score. A small personal base may stop at Level 2 and be perfectly sufficient. Complexity should follow need.

The Knowledge Base Exit Test

Before calling the system usable, ask: can it answer the questions it was built for, show where the answer came from, distinguish current from historical knowledge, expose unknowns and conflicts, and survive a new representative query without manual reconstruction?

Then ask whether someone else can maintain it. If the taxonomy, source rules or update process exist only in one person’s head, the system remains fragile.

A mature knowledge base is understandable as an operating system for knowledge: sources enter, claims are structured, conflicts are preserved, retrieval is tested, answers are traceable and stale knowledge is retired.

That is the real role of Super Intelligence in a knowledge base. SI accelerates ingestion, retrieval and synthesis, but trust comes from the architecture that keeps knowledge inspectable over time.

A Final Knowledge Governance Gate

Before a knowledge base becomes part of a recurring SI workflow, confirm four layers: the canonical source is clear, retrieval can find the relevant unit, the generated answer exposes provenance, and stale or conflicting knowledge has an explicit state.

Then run one deletion test. Remove or supersede a knowledge unit and confirm that current answers stop retrieving it. A knowledge base that can add information but cannot reliably retire it will accumulate silent contradictions.

Run one permission test as well. Ask a question whose answer exists only in a restricted record. The system should respect access boundaries rather than revealing the record because the model knows how to retrieve it.

Finally, give the knowledge base to another authorised maintainer. They should be able to explain the source registry, canonical owners, freshness rules, conflict process and evaluation set without relying on undocumented conversational history.

If those conditions hold, the knowledge base has crossed from organised notes into maintained knowledge infrastructure: something SI can use repeatedly without making trust depend on one person remembering how the system was assembled.

Operational Readiness: Can the Knowledge Base Survive a New Question?

The final readiness test is a question the system has never seen before but should be able to answer from existing knowledge. The query should require more than one unit, include one possible ambiguity and have a clear source path.

Watch the entire chain: retrieval, source selection, synthesis, uncertainty and citation back to the maintained record. If the answer succeeds only after the operator manually reconstructs missing context, the knowledge base is not yet operationally mature.

Then ask a question the knowledge base genuinely cannot answer. The correct behaviour is equally important: expose the gap, identify which source or owner could resolve it and avoid inventing a complete answer.

A trustworthy knowledge system therefore proves both capabilities: it can answer from maintained evidence when knowledge exists, and it can remain explicitly incomplete when the knowledge does not.

A Knowledge Base Is Maintained Trust, Not Stored Text

The strongest SI knowledge base knows where information came from, which version is current, what remains unknown and how future questions should retrieve evidence.

Build the source system first. Add summaries, links, retrieval and generation on top of that foundation.

When provenance and maintenance remain visible, SI becomes a powerful interface to accumulated knowledge without turning generated text into an untraceable substitute for the evidence.