everything

main screen
personal, local-first inventory
type registry
create types and things from natural language

Inspiration

Everything started three years ago with my first project on NEAR; a hackathon submission called "collect, for the common good". It was an ambitious idea motivated by the urgency of the climate crisis, meant to tap into what I believe to be the MOST undervalued (and unorganized) sector in the world: second hand product markets. collect was a combination of six apps that worked together to effectively "collect", categorize, and label items into an easily queryable “database” of real, existing, and available after-market products. Each app typically involved a camera and a free form prompt in order to describe these things.

However, there were some challenges: how to store the data in a decentralized way, and how to make upload and organization as easy as possible.

Fast forward two years, and everything evolved into the everything project, and then when BOS was released, I became obsessed with the idea of "Types on chain". I had built a proof of concept of a flexible creator based on these types, with swappable templates, and I spent months attempting a BOS-native framework for rendering predictable apps. The decentralized front end framework of BOS came with it's own challenges, but the concepts of data-first design were rock solid: data and it's types can define the way it is supposed to be used and interacted with, which makes building composable front ends much simpler -- and so many other things, too.

What it does

This project addresses the initial challenges with collect -- it stores data local first through a sync engine, public data and types are published to a decentralized, permissioned data storage layer (social-db), and new types and things can be generated from natural language, following the specified type definition because of structured outputs.

How we built it

This project consists of several components:

Vite project using near-vite-starter template, bundle stored on NEARFS, served through Web4
Web4 NEAR login to authorize a local-first session with Jazz for data storage and sync
Types stored on-chain in the social-db
Express proxy server for Open AI requests to gpt-4o-mini for NLP and structured outputs
Turborepo to support a monorepo and easy extension
Automatic form generation based on JSON Schemas, using react-jsonschema-form

Challenges we ran into

Web4 login to authorize a peer connection does not work across devices and browsers... so will need some sort of proof here, maybe.
I really wanted to use Calimero for the data privacy, but ran into challenges connecting to a peer, so opted for Jazz instead. I would still like to pursue this direction, because I think running nodes can introduce some cool value props when it comes to marketplaces.
Recursive form generation is always a head ache! What comes first, the chicken or the egg?! Sometimes you gotta hard code some things to get it started.

Accomplishments that we're proud of

I don't do great with front end design, but I actually feel pretty good with how it turned out! Also, a lot of these concepts have been burned in my brain for too long, and it feels good to get them out and in a somewhat-stable form. Perseverance!

What we learned

I learned a lot about P2P and I feel like my understanding of web technologies has shifted some over the course of the past few weeks. Although it's all still not clear, I do feel like I gained some more understanding about NEAR key pairs and how they are used to sign, which is integral to chain signatures.

What's next for everything

I want to use this app to solve my own problems -- I want to keep a record of all the things I own and publish them to marketplaces, since I will be moving soon.
I think it'd be really nice to be able to bulk import data, detect a type, and publish these types so others can bulk import items such as Instagram or Facebook data, so people can get off these platforms.
Generate UI's from data and share templates with others -- data is source of truth and you can choose how to represent it.
I'd like a multi-agent flow to be able to talk to my inventory, or have it do major reorganization for it.
Minting things and publishing to marketplaces, Keypom link drops for transferring ownership.
Everything context that can be integrated into apps, so you can access your local data from your near account proof, to use it in community-built apps.

Above all, I want to be validated in whether or not this is a worth while endeavor. With this project comes everything.dev, everything.market, every.near.page, and everythingproject.com. It's an offer for a common goal and a common mission: to build everything, for everyone. Together.