Skip to main content
active2026

silan-viking — Personal Context System

The content engine behind this website — a schema-governed personal context system that treats a half-formed idea and a published essay as the same kind of object at different lifecycle stages.

MIT
content-systemmcppersonal-knowledgerust
13 views

silan-viking is the content engine that runs this entire site. It started as
an idea — collapse the raw thought, the
published artifact, and the machine between them into one substrate — and it is
now a real, running project. This page is itself a silan-viking content item,
authored, validated, and projected by the system it describes.

What it is

One content tree on disk, six content types — idea, blog, project,
episode, update, resume — all plain Markdown + TOML, all governed by a
single schema contract (SCHEMA.md). A Rust engine parses that tree, validates
it against the schema, and projects only the items marked visibility: public
onto the live site. status is the lifecycle; visibility is the gate; the
two are never merged, so nothing leaks by accident.

Authoring runs through an MCP server: an agent can capture a loose thought,
propose a content change, and recall past context — but it can never
publish or deploy. Those stay owner-only CLI actions. The agent drafts; I
decide.

Current status — active

The engine is built and the full stack is proven end-to-end:

  • Engine — four Rust crates (silan-viking-content, silan-viking-app,
    silan-viking-cli, silan-viking-mcp) covering parse → validate → diff →
    project. Milestones M0–M9 are landed with all CI gates green.
  • Backend + frontend — a Go backend and React frontend consume the
    projected public subset; a Docker deploy pipeline is proven end-to-end.
  • CLI — silan ships with install/uninstall scripts, stage-aware guide
    hints, and the propose/accept review flow.
  • Tag system — rebuilt around a cross-type content_tag model so tags span
    all six content types.
  • Media — silan:// image resources are scanned, rewritten, and served
    through a tracked /api/v1/media endpoint.

Tech stack

A Rust core (parsing, schema validation, projection) feeds a Go backend and a
React + TypeScript frontend over SQLite, with the authoring surface exposed via
MCP and the whole thing deployable through Docker.

Open threads

  • Tag unification on the Go/ent side and in the frontend (M0.5b).
  • Non-blog detail handlers on the backend.
  • Making the agent-memory namespace (silan://agent/) a genuinely useful
    long-lived working memory rather than a scratchpad.

The system documenting itself — this project entry, drafted through propose
into the engine it describes — is the proof that it works.