databasedmcp

← Articles

How to build a home inventory with Claude

Tell Claude what you own and where it lives. Later, ask it where the drill went, or what everything is worth for the insurance form.

6 min read

databasedmcp gives your AI assistant databases it keeps between conversations, so everything in this article works from the day you connect it. Free to start, no card.

Get started free

Why build it yourself

A home inventory answers two questions: where is it, and what's it worth. You ask the first when you can't find the tent pegs, and the second when the insurer wants a list. Sortly and apps like it do this with barcode scans, photos and folders, which is more than most homes need.

Describing a shelf to Claude is quicker than filling in a form per item. Say what's in the garage cupboard and it writes the rows. Move something, and say so. When you need the list, it's a query.

Connect Claude to databasedmcp

databasedmcp is a remote MCP server that gives AI assistants private SQLite databases, with nothing to install.

In Claude on the web, desktop or mobile, open Settings → Connectors, choose Add custom connector and enter https://databasedmcp.com/mcp. Select Connect, sign in to databasedmcp with your email or Google, and select Allow. Then turn databasedmcp on for a conversation from the tools menu.

Claude asks before it runs anything that changes or deletes data. Reading runs without asking.

Any other MCP client works the same way; the docs have the details.

Copy this prompt to build it

Paste this into Claude to set up the database, its tables and its guide in one go. The rest of this article walks through what it makes and how you use it.

prompt
Set up a home inventory for me in databasedmcp, in one go.

1. Create a database called home, described as "Home inventory: places, the items kept in them, what they cost and their warranties".
2. Create two tables:
   - places: id, name (required: a cupboard, shelf or box), room (required: the room the place is in, so "Box 3" can be in "Attic").
   - items: id, name (required), place_id (references places), category, quantity (defaults to 1), price (whole euros, per item), bought_on (date), warranty_until (date, or NULL if there's none), notes (model numbers and anything else worth knowing), updated_at (defaults to now).
3. Write the database a guide that says what each table is for: one item row per kind of thing, with a quantity. It should say to check a place or item doesn't already exist before adding it, and that when something moves, you update its place_id instead of adding a second row. Include the queries for "where is it": items matching a name, with their place and room, and "value by room": price times quantity added up per room, highest first.

From then on: when I tell you what's in a place, add the place if it's new and the items in it. When I move something, update where it is and its updated_at. Show me the tables when you're finished.

Ask for the database

You don't write the schema. Describe what you want:

Set up a home inventory in databasedmcp: the places things are kept (rooms, cupboards, boxes), and items with where they are, how many, what they cost, when I bought them and when the warranty ends. Add what I say is in each place, and update it when I move something.

Claude creates a database called home and its tables:

schema
CREATE TABLE places (
  id INTEGER PRIMARY KEY,
  name TEXT NOT NULL,
  room TEXT NOT NULL
);

CREATE TABLE items (
  id INTEGER PRIMARY KEY,
  name TEXT NOT NULL,
  place_id INTEGER REFERENCES places(id),
  category TEXT,
  quantity INTEGER NOT NULL DEFAULT 1,
  price INTEGER,
  bought_on TEXT,
  warranty_until TEXT,
  notes TEXT,
  updated_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP
);

It also writes the database a guide on how the tables are meant to be used. The guide comes back with the schema whenever an assistant looks the database up. Claude files things the same way next week as today, and so does any other assistant you connect.

guide
# home: what we own and where it is

- **places**: rooms, cupboards, shelves, boxes. `room` is the room a place is in, so "Box 3" can live in "Attic".
- **items**: one row per kind of thing, with `quantity`. `price` is what it cost per item, in whole euros. `warranty_until` is a date or NULL. `notes` holds model numbers and anything else worth knowing.

Before adding a place or item, check it doesn't exist. When something moves, update `place_id`; don't add a second row.

Where is it: `SELECT i.name, p.name AS place, p.room FROM items i JOIN places p ON p.id = i.place_id WHERE i.name LIKE ?`

Value by room: `SELECT p.room, sum(i.price * i.quantity) AS value FROM items i JOIN places p ON p.id = i.place_id GROUP BY p.room ORDER BY value DESC`

Use it

From here on you talk, and Claude writes the rows. Each request below is one statement:

Add the places: the tall cupboard in the garage, the shelf above the washing machine, and the blue box in the attic.
execute
INSERT INTO places (name, room) SELECT json_extract(value, '$.name'), json_extract(value, '$.room') FROM json_each(?)
-- params: ["[{\"name\":\"Tall cupboard\",\"room\":\"Garage\"},{\"name\":\"Shelf above washer\",\"room\":\"Utility room\"},{\"name\":\"Blue box\",\"room\":\"Attic\"}]"]
In the garage cupboard: a cordless drill I bought in March for 129 euros, two-year warranty, and a box of 40 tent pegs.
execute
INSERT INTO items (name, place_id, category, quantity, price, bought_on, warranty_until) SELECT json_extract(value, '$.name'), ?, json_extract(value, '$.category'), json_extract(value, '$.qty'), json_extract(value, '$.price'), json_extract(value, '$.bought'), json_extract(value, '$.warranty') FROM json_each(?)
-- params: [1,"[{\"name\":\"Cordless drill\",\"category\":\"tools\",\"qty\":1,\"price\":129,\"bought\":\"2026-03-14\",\"warranty\":\"2028-03-14\"},{\"name\":\"Tent pegs\",\"category\":\"camping\",\"qty\":40,\"price\":null,\"bought\":null,\"warranty\":null}]"]

Everything on one shelf goes in as one statement.

The winter duvets are in the blue box in the attic. Two of them, about 80 euros each.
execute
INSERT INTO items (name, place_id, category, quantity, price) VALUES (?, ?, ?, ?, ?)
-- params: ["Winter duvet",3,"bedding",2,80]
I moved the drill to the shelf above the washer.
execute
UPDATE items SET place_id = ?, updated_at = datetime('now') WHERE name LIKE ?
-- params: [2,"%drill%"]

Ask it questions

Once there's data, each report you'd pay for is a single query:

Where's the drill?
query
SELECT i.name, p.name AS place, p.room, i.updated_at FROM items i JOIN places p ON p.id = i.place_id WHERE i.name LIKE ?
-- params: ["%drill%"]
What's everything worth, room by room? It's for the insurance form.
query
SELECT p.room, count(*) AS items, sum(i.price * i.quantity) AS value_eur FROM items i JOIN places p ON p.id = i.place_id WHERE i.price IS NOT NULL GROUP BY p.room ORDER BY value_eur DESC
Which warranties run out in the next six months?
query
SELECT name, bought_on, warranty_until FROM items WHERE warranty_until BETWEEN date('now') AND date('now', '+6 months') ORDER BY warranty_until

You can also open the database on the website, page through its rows and run read-only SQL yourself.

What you give up

There are no photos, receipts or barcode scans. Sortly lets you photograph a shelf and scan a label. Here every item is a sentence you said, and receipts stay wherever you keep them. For an insurance claim, take a photo of the room anyway, and note where it's saved in the item's notes.

Nothing alerts you when a warranty is about to end or stock runs low. You ask. You also won't have an app to carry around the house while you count. If you're cataloguing a workshop or a small business's stock, the scanning alone may be worth paying for.

Try it

databasedmcp is free to start, with no card. Free has 100 tool calls a week, enough to set this up and try it for a week. Starter has 1,000 for everyday use.

Create an account

More articles · databasedmcp · Docs