ltcai 4.0.0

Lattice AI — local-first Digital Brain Platform: knowledge graph with provenance, durable memory, hybrid search, real agent/workflow runtimes, and signed brain exchange

Lattice AI

A local-first Digital Brain Platform. Your Knowledge Graph is the durable asset; models just read it.

Every source — files, folders, web pages, browser tabs — converges into one Knowledge Graph on your own machine. Connect models, agents, and search to that graph instead of placing your work inside any single model.

Lattice AI is not a model-personalization system. It is a Digital Brain Platform. The Knowledge Graph is your durable asset. Models are replaceable. Knowledge is durable.

It isn't another chat window, and it isn't a way to "fine-tune a model on you." The purpose of Lattice AI is to connect models to your Knowledge Graph — your digital brain — not to place you inside a model. AI reads your knowledge; you own it.

• Models are replaceable. Swap MLX, Ollama, LM Studio, or a cloud LLM at will.
• Agents, RAG, and the UI are replaceable. They are implementations, not the asset.
• Your Knowledge Graph is durable. It outlives every model and is yours to export, import, and back up locally — no cloud required.

Local-first by default; cloud only when you choose. (The Vercel site is a landing/download/demo surface only — never the runtime. Lattice AI runs on your machine over local SQLite.)

Why install Lattice AI?

Most AI tools only answer questions in a chat window. Lattice AI gives you a workspace around the work itself:

• Keep everything in one place — files, notes, chats, and decisions live together instead of scattered across tabs and apps.
• Turn documents into knowledge — uploads and connected folders become searchable, linked context you can reuse.
• Search the way you think — fuse keyword, vector, and knowledge-graph signals in a single query.
• Stay private and offline-capable — run local models through MLX, Ollama, or LM Studio; nothing leaves your machine unless you opt in.
• Use cloud models only when you choose — bring an API key for cloud LLMs when you want them, not by default.
• Inspect every agent run — the built-in runner persists plans, reviews, retries, and results as replayable run records. Today that runner is deterministic and does not call a model; LLM-driven execution is the v4 runtime, in progress.

Lattice AI is not a clone of ChatGPT, Claude, Cursor, Obsidian, or Notion. It sits in a different place: a workspace that ties local/self-hosted AI, your files, project knowledge, hybrid search, local and optional cloud models, agents, and workflows together — and runs on your own hardware.

What can you do with it?

• Build a private AI workspace for a project, scoped to your machine.
• Chat with your local files, images, and workspace memory.
• Upload documents — or connect a folder — and turn them into searchable knowledge.
• Explore how files, decisions, conversations, and entities connect in a Knowledge Graph.
• Run local models through MLX, Ollama, or LM Studio, and use cloud LLMs only when you want to.
• Define agent workflows and replay their run records step by step (execution is deterministic scaffolding today — it does not yet call a model).
• Separate personal work from organization work.
• Switch between Basic, Advanced, and Admin modes depending on your role.

Product Tour

Start from the workspace home

The home view shows workspace readiness, model state, retrieval status, and the main entry points — derived from real local state, never placeholder counters.

Chat with files, images, and workspace context

Chat is wired to your files, graph context, memory, and model routing — including vision-capable image input by attach, drag-and-drop, or paste.

Bring documents into the workspace

Uploads and connected folders become indexed workspace context, searchable from chat and hybrid search.

Understand knowledge visually

The Knowledge Graph shows how files, decisions, conversations, and entities connect — context that stays useful even when you switch models.

Inspect agent run records

The agent runner turns a goal into an inspectable, replayable run record — roles, logs, review, and retry — that you can read back step by step. The runner shown here is deterministic and LLM-free; real model-driven execution is the v4 runtime, currently in progress.

Extend with hooks and the local runtime

Advanced users wire lifecycle hooks into runs, tools, workflows, uploads, and indexing — and see the on-device local runtime's real status, handshake, and folder-watch activity.

Install

Install the local workspace:

pip install ltcai

Add Apple Silicon local model support:

pip install "ltcai[local]"

Install the npm CLI:

npm install -g ltcai

Install the coding extension:

• VS Code Marketplace: parktaesoo.ltcai
• Open VSX: parktaesoo.ltcai
• GitHub Releases

Quick Start

Start the workspace:

LTCAI

Then open:

http://127.0.0.1:4825/app

Working from a development checkout:

npm install
npm run dev

Core Features

• Local-first workspace — your data, models, and workspace state live on your machine by default; cloud is opt-in.
• Files and connected folders — upload documents or connect a local folder; Lattice indexes them and watches connected folders for changes.
• Chat with workspace context — conversations are grounded in your files, knowledge graph, and memory, with vision-capable image input.
• Knowledge Graph — files, images, notes, conversations, and decisions become linked entities and relationships you can explore.
• Hybrid Search — keyword, vector, and graph signals are fused into one ranked result set.
• Local model support — run multimodal models locally via MLX, Ollama, or LM Studio, with hardware-aware recommendations and source disclosure.
• Optional cloud model routing — add OpenAI-compatible or other cloud models when you choose; model cards disclose origin, run mode, and internet use.
• Multi-agent workflows — turn goals into runs with roles, handoffs, review, retries, and replayable timelines.
• Skills, hooks, tools, and MCP — extend the workspace with skills, lifecycle hooks, a governed tool registry, and Model Context Protocol servers.
• Personal / Organization workspaces — keep personal work separate from team work with role-aware views.
• Basic / Advanced / Admin modes — show only what each role needs, from core workflows to agent tooling to administration.

Latest Release

v3.6.0 — Knowledge Graph First

• Unified ingestion pipeline — one entrypoint normalizes every source (file, folder, web URL, browser tab, text/markdown/code) into the graph, idempotent by content hash and bracketed by the pre_tool/post_tool hook lifecycle.
• Formalized entity/relationship model — first-class Source, Repository, Meeting, Organization, Workflow, Agent entities and indexed_from, modified_by, belongs_to_project, part_of, discussed_in, decided_by, generated_by, used_by_agent relationships.
• Browser & web ingestion — POST /api/browser/read-url and /ingest-current-tab, plus a local Manifest V3 extension that posts only to 127.0.0.1.
• Portability — local Knowledge Graph export/import (versioned JSON) and binary backup/restore (DB + blobs, integrity-checked). No cloud required.
• Provenance — every node records where it came from; a queryable audit trail makes the graph explainable.
• Knowledge Graph as the primary surface — the view becomes your digital brain with Status, Sources, Capture, and Backup tabs.

See RELEASE_NOTES_v3.6.0.md, docs/kg-schema.md, docs/RUNTIME_HOOK_COVERAGE_v3.6.0.md, and FEATURE_STATUS.md.

How it works — every source converges into the graph

As of v3.6.0, all data sources flow through one unified ingestion pipeline into the Knowledge Graph — no source bypasses it, none becomes an isolated silo:

source (file · folder · PDF · web URL · browser tab · text)
  -> extraction -> normalization -> content hash (idempotent)
  -> chunking -> entity detection -> relationship detection -> embedding
  -> Knowledge Graph  (Source -[indexed_from]- content -[contains]- chunks)
  -> RAG / agents / memory / hybrid search

• Every node is explainable. Each ingested item carries provenance — where it came from, when, how it was processed, whether it was embedded or linked.
• The graph is the asset. Memory, search, and agents are views over it; models read it. Swap a model and your knowledge is unchanged.
• Portable, no cloud. Export/import the graph as JSON, or take a full local binary backup (DB + blobs) and restore it.
• Local-first protects the graph. It lives in local SQLite on your machine.

For the deeper design, see ARCHITECTURE.md and docs/architecture.md.

Documentation

Product and principles

• PROJECT_PRINCIPLES.md — product principles
• AI_PHILOSOPHY.md — how AI is used in the workspace
• MODEL_POLICY.md — local model recommendation policy

Architecture

• ARCHITECTURE.md — workspace, graph, pipeline, and model overview
• docs/architecture.md — full architecture reference
• docs/V3_BACKEND_ARCHITECTURE.md — backend storage, search, and retrieval

Knowledge and retrieval

• KNOWLEDGE_GRAPH.md — graph model and behavior

Agents and workflows

• docs/MULTI_AGENT_RUNTIME.md — multi-agent workflow runtime
• docs/WORKFLOW_DESIGNER.md — AI pipeline designer

Extensions

• docs/PLUGIN_SDK.md — plugin SDK

Releases

• RELEASE_NOTES.md — current release notes
• RELEASE_NOTES_v3.6.0.md
• RELEASE_NOTES_v3.5.0.md
• RELEASE_NOTES_v3.4.1.md
• RELEASE_NOTES_v3.4.0.md
• CHANGELOG.md and docs/CHANGELOG.md

Release History

Version	Theme
3.6.0	Knowledge Graph First — unified ingestion pipeline, formalized entity/relationship model, browser/web ingestion, local export/import/backup, provenance, KG as the primary surface
3.5.0	Foundation stabilization & verification — OIDC verifier, trusted-proxy gating, runtime hook coverage, tools/ package, reproducible artifacts
3.4.1	Runtime completion — full hooks lifecycle, real Local Agent probes, Connect Folder and Folder Watch verified end-to-end
3.4.0	Platform completion — hooks execution, uploads in Files, vision image input, agent run trigger, on-device Local Agent / Connect Folder / Folder Watch
3.3.1	Visual product rebuild — rebuilt /app shell, Basic/Advanced/Admin navigation, refreshed design system
3.3.0	Product quality & honesty release — evidence-based feature audit, single-source version truth, working document upload, documented design system
3.2.0	Feature-complete platform — multi-agent collaboration, agent registry, marketplace + templates, workflow agents, long-term memory, skills/hooks/tool registries, MCP manager
3.1.0	Mainline platform completion — native /app workflows, production embedding profiles, AgentRuntime/registries, hashed v3 assets
3.0.1	Release-blocker remediation — provider-backed embeddings, unified AgentRuntime boundary, every v3 surface connected or clearly unavailable
3.0.0	v3 local-first AI workspace platform — /app, Native Chat, Knowledge Graph, Vector Index, Hybrid Search, workspace modes
2.2.7	Visual system stabilization — cohesive dark/light screens, crisp chat composer, dark graph canvas, Workspace OS polish
2.2.6	Token-native CSS foundation
2.2.5	Release hygiene hotfix — dark overlays, modal stack, cache-busting, favicon, and Telegram log masking
2.2.4	Chat dark-mode completion
2.2.3	Frontend stability and UX fixes
2.2.2	Frontend QA stabilization — mobile nav, admin actions, overflow fixes, and expanded visual tests
2.2.1	Frontend and UX overhaul for responsive workspace, themes, graph UX, admin reflow, and file attachment
2.2.0	Multimodal-first Knowledge Graph and local model source disclosure
2.1.0	Multi-agent workflow maturity
2.0.0	AI pipeline, workflow, and plugin platform foundation
1.7.0	Graph and collaboration
1.6.0	Product experience deepening

License

MIT