@fortemi/core

fortemi-react

The browser edition of the Fortémi intelligent-database stack — profile-scoped interchange, client-side, local-first, private by default.

Run the Fortémi schema entirely in the browser: real PostgreSQL (PGlite + pgvector), typed React 19 hooks, and profile-scoped Knowledge Shard archives. Build notebooks, research tools, and AI-powered knowledge apps where the data lives on the user's device, search runs locally, and any cloud or AI provider is opt-in and yours to choose — no backend, no account, no lock-in.

pnpm add @fortemi/core @fortemi/react
pnpm dev

What Fortémi Is · Why · Get Started · Packages · Features · AI Capabilities · Documentation · License

What Fortémi Is

Fortémi is an intelligent database for AI-ready applications: normalized data contracts plus data-science and processing tooling that turn messy organizational data into searchable, linkable, provenance-aware structures. The Fortemi server owns the live APIs and Knowledge Shard authority; @fortemi/core consumes the declared browser profiles, and HotM consumes the server and Core contracts as an application. Receipt-bound profiles provide a common interchange surface without implying one schema across every plane.

fortemi-react is the browser edition of that stack. It runs the normalized schema in PGlite/pgvector with profile-scoped interchange — the browser read/write/search core plus an opt-in, sandbox-limited slice of on-device inference. Knowledge management is one use case built on the substrate, not the whole product. What the browser edition uniquely adds: the data never has to leave the device. Local-first and private-by-default stay the headline differentiators.

Fortémi (product) vs @fortemi/core (embeddable library)

@fortemi/core is an embeddable library — the headless data layer other tools build on. (For example, it is AIWG's default index and discovery backend, reading from a static local cache.) A tool that embeds @fortemi/core is not running Fortémi: it is using the library's schema and query surface inside its own process, and the library ships no data anywhere by default. Fortémi the product is the full stack — the server or this browser edition — with its job pipeline, capability system, and portable archives.

Why fortemi-react

Most in-browser data stacks make you choose: capable but cloud-bound, or private but primitive. fortemi-react refuses the trade-off — it runs a full PostgreSQL engine inside the browser, so data never has to leave the device to be searchable, structured, and AI-ready.

• Private by default. Notes live in the browser on the user's device — no server, no sync service, no cloud backup, no account. The only thing that ever leaves the device is a cloud AI call you explicitly opt into.
• Capable, not toy-grade. Real PostgreSQL with tsvector full-text, pgvector HNSW semantic search, and BM25 reciprocal-rank fusion — production-grade retrieval that stays fast as an archive grows, entirely client-side.
• AI on your terms. Embeddings and LLMs are opt-in and bring-your-own: run locally (WebGPU, Ollama, LM Studio, llama.cpp, vLLM, Jan) or route to a provider you control. Nothing is wired to a vendor you can't swap out.
• Yours to keep. Knowledge Shard archives (tar.gz, with checksums and a declared portability profile) export the components supported by that profile on demand, and the AGPL-3.0 license keeps the stack open. No lock-in by design.

Use it when you need local-first note storage, semantic retrieval, agent-readable tool functions, or portable archives inside a web application — whether that's a personal notebook, a research workspace, or a product that must keep user data on the user's device.

Quick Start

Install the published packages:

pnpm add @fortemi/core @fortemi/react
# or
npm install @fortemi/core @fortemi/react

Run the standalone app from this repository:

pnpm install
pnpm dev          # http://localhost:5173

Minimal React setup:

import { FortemiProvider, useCreateNote, useSearch } from '@fortemi/react'

export function App() {
  return (
    <FortemiProvider persistence="opfs" archiveName="default">
      <Notebook />
    </FortemiProvider>
  )
}

function Notebook() {
  const { createNote } = useCreateNote()
  const { data, search } = useSearch()

  return (
    <main>
      <button onClick={() => void createNote({ title: 'Hello', content: 'First note.' })}>
        Add note
      </button>
      <input onChange={(event) => void search(event.target.value)} />
      <ul>
        {data?.items.map((item) => <li key={item.id}>{item.title}</li>)}
      </ul>
    </main>
  )
}

Packages

All packages are versioned together — the npm badges above always show the current release.

Contract Evidence

Fortemi authority run 6393 passed the same pinned authority-to-consumer contract on Linux x86_64, Linux arm64, and macOS arm64. The matrix binds React/Core commit ccf96fad6025025293e40e250c85f088c8999d86 to @fortemi/[email protected] (tgz SHA-256 e282f504a842261c3f598a7f2ee0d6a85e03dc213ddf545a18daf5f603a742cc; tar payload SHA-256 47482320b543307c2d44f3a87a2268ead6faf265c6bd38cf33011e0ac7f8e77a).

This evidence covers the declared Fortemi authority -> React/Core -> HotM consumer surface and exact Knowledge Shard 2.0.0/full-v1 behavior on those three platform cells. Windows remains deferred to Fortemi #1096. The suite audit in Fortemi #1081 remains NO-GO; this evidence does not prove suite-wide portability, complete backup, every architecture, launched GUI/native-dialog behavior, or one shared schema across the static-index, state-transfer, and live-persistence planes.

What You Get

• Full note CRUD with revision history, soft delete, starring, pinning, and archiving
• PGlite-backed local storage with opfs, idb, and memory persistence modes
• Writable canonical record tier that runs without PGlite — journaled IndexedDB records, Bytecask attachment bytes, DB-free shard import/export, and a rebuildable PGlite projection
• Full-text search with PostgreSQL tsvector / tsquery, phrase search, filters, facets, snippets, bounded metadata predicates, and safe source evidence locators
• Hybrid semantic search with pgvector HNSW and BM25 reciprocal-rank fusion
• Virtual embedding-set selectors, cached similarity graphs, and graph/community artifact persistence
• Dynamic and user-authored communities with React graph-controller hooks for source switching
• Tags, collections, inter-note links, SKOS schemes, concepts, and relations
• Knowledge Shard tar.gz import/export with checksums, exact schema/profile negotiation, and receipt-backed component preservation
• Fortemi source-note-upsert/1.0.0 live persistence in PGlite and RecordStore, with bounded atomic batches, checkpoints, replay-safe outcomes, and typed shard loss because source identities are outside current profiles
• 10 manifest-backed Fortemi tools plus 11 exported direct tool helper functions
• Optional embeddings, LLM, local-provider discovery, WebGPU detection, and fallback routing
• React 19 hooks for common UI workflows and direct context access for lower-level integration

Runtime Support

No backend is required. Deploy apps/standalone/dist/ to any static host.

AI Capabilities

fortemi-react supports opt-in capabilities through the runtime capability manager:

On Linux Chrome, local WebGPU inference commonly needs:

google-chrome --enable-features=Vulkan --enable-unsafe-webgpu http://localhost:5173

Tool Integration

@fortemi/core exports fortemiManifest for bridge registration and direct helper functions for application code. The manifest currently includes:

capture_knowledge, manage_note, search, get_note, list_notes, manage_tags, manage_collections, manage_links, manage_archive, manage_capabilities.

Direct helper exports also include manageAttachments for attachment metadata and blob operations.

Development

pnpm install
pnpm typecheck
pnpm lint
pnpm test:core
pnpm test:e2e
pnpm build
pnpm examples:site:build && pnpm examples:site:e2e   # built-gallery smoke test

The repository uses Node.js 22, pnpm 10, TypeScript, Vitest, Playwright, and Vite.

Documentation

License

AGPL-3.0-only. See LICENSE.