Project knowledge for you and your AI tools

Stop re-explaining your project.

Keep explanations, decisions and reports connected to the project they describe—so people and AI tools can find and reuse the context.

Keep useful knowledge close

Keep the explanation where it belongs.

Attach an explanation to the part it describes. In this example, an annotation is linked to a specific range in engine.py.

The same idea, beyond code

Not just code.

A code range. A region in an image. Keep annotations connected to the part you are talking about.

From a question to useful context

Ask your project. See how it fits together.

Explore a conversation alongside a visual explanation. Inspect the project context referenced in the example.

From the overview to the detail

From reports back to sources.

Read the overview, inspect component relationships, and see the source context around them.

Keep understanding with the project

Share the understanding. Not just the files.

Export connected knowledge as a portable snapshot. Keep it with your GitHub repository or pass the file on, so others can explore the context behind your work.

Every source opens with the knowledge already attached to it.

Explore a sample Get Lumvise

Interactive product walkthrough

Lumvise Workspace

Knowledge Centerkarpathy__microgradearth-observatoryImport folderSearch project…⌘KGuideSettings

OverviewGraphFileCanvas

nn.pymicrograd/nn.pyGenerate knowledge

Sources › Document→Knowledge8 Elements2 Artifacts60 Lines

1import random2from micrograd.engine import Value34class Module:56    def zero_grad(self):7        for p in self.parameters():8            p.grad = 0910    def parameters(self):11        return []1213class Neuron(Module):1415    def __init__(self, nin, nonlin=True):16        self.w = [Value(random.uniform(-1,1)) for _ in range(nin)]17        self.b = Value(0)18        self.nonlin = nonlin1920    def __call__(self, x):21        act = sum((wi*xi for wi,xi in zip(self.w, x)), self.b)22        return act.relu() if self.nonlin else act

Artifacts 2

Functional meaning: nn.pySummary of the neural network module

From scalars to a neural networkDevelopment notes and key ideas

Knowledge 3

microgradnnneural-network

Module and parametersHow Module, parameters() and zero_grad work together

Neuron initializationWeight initialization and bias

Design rationaleWhy this minimal implementation works

Extracted elements 8

Moduleclass

Neuronclass

engine.pymicrograd/engine.pyGenerate knowledge

Sources › Document→Knowledge14 Elements3 Artifacts94 Lines

50        out._backward = _backward5152        return out5354    def backward(self):5556        # topological order all of the children in the graph57        topo = []58        visited = set()59        def build_topo(v):60            if v not in visited:61                visited.add(v)62                for child in v._prev:63                    build_topo(child)64                topo.append(v)65        build_topo(self)6667        # go one variable at a time and apply the chain rule68        self.grad = 169        for v in reversed(topo):70            v._backward()7172    def __neg__(self): # -self

observation-islands.pngimagery/observation-islands.pngGenerate knowledge

Sources › Document→Knowledge3 Elements2 Artifacts

Artifacts 2

Observation islands: select the mountain regionAnnotation · region

Observation islands: original CC0 demo illustrationAnnotation · file

Knowledge 6

demomediasource-mappingearth-observatorynon-codeannotation

Image region is connected to this annotation

Knowledge Project structure

Project structure

Micrograd is a deliberately small automatic-differentiation engine plus a compact neural-network library.

AreaMain entryAutodiff engineValue classNeural-network libraryNeural-network moduleTraining demonstrationMicroGrad demo

The engine builds a graph of scalar Values; nn.py stacks Neurons, Layers and an MLP on top of it.

Canvases Functional Component Map

Functional Component Map

microgradnn.pyJob: Defines a minimal neural-network stack (Module; Neuron; Layer; MLP) over micrograd Value scalars.test_engine.pyJob: Validate micrograd’s Value autograd engine against equivalent PyTorch computations.Valueinstantiates ×1instantiates ×2

Report mentions a component

Open related diagram

ContextConversation

Context

nn.pymicrograd/nn.py Python

Neural network module with basic building blocks for micrograd.

Artifacts2On canvases0

Child elements 8

Moduleclass L4–L11

Neuronclass L13–L31

Layerclass L33–L48

MLPclass L50–L60

Show all 8 elements →

Context

engine.pymicrograd/engine.py Python

Scalar-valued autograd engine: the Value class and its backward pass.

Artifacts3On canvases1

Child elements 14

Valueclass L2–L94

__add__method L13–L22

__mul__method L24–L33

backwardmethod L54–L70

Why backward accumulates gradientsAnnotation · demo, micrograd L54–70

backward() performs a reverse topological traversal and accumulates gradients in each node. A value can be reached by multiple paths in the computation graph, so gradients from all paths are summed (chain rule).

Value: a scalar and its derivativeDefinition · demo, microgradL2–94

Functional meaning: engine.pyFunctional summaryL1–94

Context

observation-islands.pngimagery/ PNG

Synthetic CC0 illustration of an island chain seen from orbit.

Artifacts2Regions1

Project

Earth Observatorydemo collection 9 sources

earth-observation-demo.pdfdocument documents/

mauna-loa-monthly-co2.csvdata measurements/

AI explanationExplain again

This image shows a synthetic illustration of an island chain with a mountainous island, clouds and a satellite, created for the Earth Observatory demo project.

The highlighted region focuses on the central mountain, which the annotation uses to discuss terrain, landcover and scene composition.

Why it exists

Part of a mixed-format demo collection—images, reports, media—showing knowledge connected across file types, not just code.

ConversationClose

YouExplain me how the tests evaluate the project

AssistantHow the tests evaluate micrograd

The project’s tests live in a single pytest module, test/test_engine.py (test_sanity_check, lines 4–26, and test_more_ops). Per the indexed artifact “Functional meaning: test_engine.py”, their job is:

Validate micrograd’s Value autograd engine (forward and backward passes) against equivalent PyTorch computations.

How they work
1. Differential testing against PyTorch — each test builds the same scalar expression twice.

test/test_engine.py

Ask a question about this project…

Context

Project structureKnowledge · report

Overview of micrograd’s areas and their main entry points.

Mentions 3

Valueclass engine.py

Moduleclass nn.py

MicroGrad demonotebook demo.ipynb

ValueClass in engine.py

Referenced by

nn.pyinstantiates ×1

test_engine.pyinstantiates ×2

Defined in

engine.pyL2–94

Jump to source file

A shared space to think

Talk it through. Shape it together.

The desktop dashboard brings your assistant and an editable canvas together. Work through a release decision, connect access rules to the code, and capture what the team needs to verify before shipping.

Interactive product walkthrough

Interactive canvas

Assistant whiteboard

idle

Guide

Try the LLM and microphone buttons for a sample exchange. Drag a canvas card, or select it and use the arrow keys. Edit its label below. Switch to the Lattice Panel to inspect the project connections.

Release review: client project sharing

Decision: private client access. Publishing is a separate owner action.

Selected cardEdits stay in this demo.

Assistant: “Agree the access model first: clients get viewer access, editors update knowledge, and owners manage membership and publication.”

Sample release discussion · no live AI or audioExplore on Mac

Choose with the evidence in view

Where Lumvise fits.

Compare selected documented capabilities. Open a checkmark to see its source, scope and review date.

Interactive product walkthrough

Compare with

Documented capability	Lumvise	Cognee	Zep	Mem0	Supermemory	Graphiti
Visual workspace for source files, knowledge and graphLumvise difference
Interactive assistant dashboard with editable canvasLumvise difference
Knowledge pinned to exact code lines and image regionsLumvise difference
Shareable snapshot others explore in a browserLumvise difference
MCP access for your AI tools
Semantic retrieval
Graph-based relationships
Local / self-hosted knowledge runtime

DocumentedPartial / different focusNot documented

Selected documentation review · 2026-10-09 · Open any mark for its source. “Not documented” means not found in the reviewed documentation. Not a performance benchmark.

Start in the way that fits

Choose how you access Lumvise.

Explore on Mac, use project knowledge through MCP, or open an exported graph in your browser.

Interactive product walkthrough

Desktop

The Mac workspace

The complete experience: workspace, knowledge tools and the desktop Assistant.

Graphical workspace and knowledge editor
Desktop Assistant with canvases
One-click agent integrations

Download Full

AI tools

Your AI tools, connected

Pick your assistant. It reads and saves project knowledge through Lumvise’s local MCP server.

Claude CodeOne click in Lumvise Full

Open Settings → Agent integrations
Choose Claude Code, select Install
Ask about your project—it uses Lumvise

Browser

Explore in your browser

Open an exported graph—no installation. The viewer is separate from the desktop app.

ChatGPT, Claude and Grok on the web need an authenticated remote MCP gateway; the AI-tools setup is for desktop and terminal clients.

A few useful distinctions

Before you start.

Is the product walkthrough a live AI session?

No. The walkthrough animates product UI and uses examples captured from the desktop app. Its controls guide the demonstration; they do not run a live AI session. Explore the online sample for the graph viewer, or use the desktop app for the assistant experience.

Does every explanation become saved project knowledge?

No. The provided app capture distinguishes on-demand explanations from retained artifacts. The page does not claim automatic persistence of every response.

Can I open any GitHub repository?

This browser flow expects a public repository containing an existing .lv/graph.pz export, or a direct public HTTPS link to a .pz archive. It does not import and analyze arbitrary repositories.

Is sharing the same as live synchronization?

No. The illustrated GitHub and file-sharing flow uses an exported snapshot. Refreshing that snapshot and live collaboration are different capabilities.

Which edition should I choose?

Full includes the graphical workspace and desktop Assistant. Community is a headless runtime for MCP-capable tools. Both share the local knowledge core; check the release notes for current details.

What platforms are available?

The reviewed installer release is for Apple Silicon Macs with macOS 14 or later. The browser graph viewer is a separate access option. Do not treat source-build possibilities as downloadable Windows or Linux releases.

Does local storage mean every AI operation stays on my computer?

Not necessarily. Data handling depends on the access mode and configured AI services. Review the privacy notice and the application configuration before using private project data.

Your project.
With its understanding.

Explore a sample

Explore Safetensors in the online graph viewer.

Stop re-explaining your project.

Keep the explanation where it belongs.

Not just code.

Ask your project. See how it fits together.

From reports back to sources.

Share the understanding. Not just the files.

Artifacts 2

Knowledge 3

Extracted elements 8

The Mac workspace

Your AI tools, connected

Explore in your browser

Before you start.

Your project.With its understanding.

Your project.
With its understanding.