I have a pressing need to come up with a household budget and had already decided to try using LLMs to help on this task since learning LLMs/prompt engineering is more fun than just writing a dumb script to do accounts.

Thought i would try this tool - and here's a quick review of the experience:

- the quickstart instructions are very clear and I was up and running on my localhost (a mac - but I think this will work well on windows and linx too)

- the UX is good ... slight wrinkle is that the upload button has a down arrow ... also Ctrl+Shift+/ doesn't work on a mac - took me a while to find the speech bubble icon in the bottom right

- love the import / export, love the chat box - worked well with my existing OpenAI account

So - this is a fantastic concept and a well executed MLP - thanks.

That said - and I highly encourage you to keep going - there are a couple of caveats:

1. The task I set is realworld - "please categorize my bank transactions into household expense groups" - and proved too much for my ChatGPT o1 account - most lines were labelled as 'other', bank charges were labelled 'fuel', etc, etc - so the underlying AI engine is not yet ready for this sadly (I am happy to be corrected if others know the recipe)

2. I wonder if using a tool like this, a set of LLM prompts to set up the query and to comb the response would help to chip away at [1] ... so I suggest that having a way for my config to accumulate my prompts maybe a nice feature.

Please do not take this f/back as negative to your work ... it is more my getting to grips with the AI sweet spot.

Thanks for taking the time to try it out and share your thoughts. I really appreciate the detailed feedback from a real-world use case.

Glad to hear the setup was smooth and that the chat box + import/export features worked well for you. Noted on the UI tweaks, I'll look into making them more intuitive.

On the categorization issue, yeah, LLMs can struggle with nuanced transaction labeling, especially without proper context or examples. Structured prompting could help, which ties into your second point -- having a library of refined prompts that can be reused for repetitive tasks would be really valuable.

I love your feedback -- it's exactly what helps improve the tool. And again, thanks for testing it out!

Prompt library has also been implemented and can be opened with ctrl+shift+L; or cmd+shift+L on mac

having thought about this a bit - my new conjecture is that if I had a way to feed in an example map of transaction payee => category, as one of the prompts, and a way to incrementally add prompts for outliers, then the AI _might_ be able to do a reasonable job - I am planning to mess with raku LLM::Functions to see if I can get this to work

Hi I've been thinking about the same thing, in the context of beancount / plain text accounting.

https://www.reddit.com/r/plaintextaccounting/s/BKsaLrfy3A

I already have thousands of labeled examples and a list of valid categories. I'm also hoping an llm will do a reasonable job.

At the moment I'm wondering what to do with all the example transaction data, as it's likely larger than the context window. I guess I could take a random downsample, but perhaps there's a more effective way to summarize it.

Any plans to add a config for a Dockerfile/docker-compose.yml? This could be really useful in a self-hosted environment. If you go down this route, the ability to use something like Ollama in place of OpenAI would be a nice feature as well.

Docker config is already implemented—you can check out the repo now. Adding support for other LLM providers like Ollama is something to consider for future development. Thanks for the suggestion!

One of the things that has seemed suboptimal to me is having AI “write code”.

Doesn’t it make more sense to ask AI a question, and the AI figures out what code is needed to answer the question, run it, and report the answer?

From the description sounds like this project is a step in that direction.

OTOH, what is "code"? In a general sense, I think of "code" as the "codification of a process." If we want to know what steps the AI is following to complete a process, then having an AI write code seems like a correct and necessary part of the solution.

Very cool!! Do y'all have an use-your-own-key example deployment to try it?

Thanks you!

Right now, you can clone the repo and follow the instructions to run it locally with your own OpenAI key. I'm working on a hosted demo that will let you try it out directly without any setup. stay tuned :)

TIL that Apache Echarts can generate WAI-ARIA accessible textual descriptions for charts and supports WebGL. https://echarts.apache.org/en/feature.html#aria

apache/echarts: https://github.com/apache/echarts

Marimo notebook has functionality like rxpy and ipyflow to auto-reexecute input cell dependencies fwiu: https://news.ycombinator.com/item?id=41404681#41406570 .. https://github.com/marimo-team/marimo/releases/tag/0.8.4 :

> With this release, it's now possible to create standalone notebook files that have package requirements embedded in them as a comment, using PEP 723's inline metadata

marimo-team/marimo: https://github.com/marimo-team/marimo

ipywidgets is another way to build event-based UIs in otherwise Reproducible notebooks.

datasette-lite doesn't yet work with jupyterlite and emscripten-forge yet FWIU; but does build SQLite in WASM with pyodide. https://github.com/simonw/datasette-lite

pygwalker: https://github.com/Kanaries/pygwalker .. https://news.ycombinator.com/item?id=35895899

How do you record manual interactions with ui controls and spreadsheet grids to code for reproducibility?

> "Generate code from GUI interactions; State restoration & Undo" https://github.com/Kanaries/pygwalker/issues/90

> The Scientific Method is testing, so testing (tests, assertions, fixtures) should be core to any scientific workflow system.

ipytest has a %%ipytest cell magic to run functions that start with test_ and subclasses of unittest.TestCase with the pytest test runner. https://github.com/chmp/ipytest

How can test functions with assertions be written with Probly?

Probly doesn't have built-in test assertion functionality yet, but since it runs Python (via Pyodide) directly in the browser, you can write test functions with assertions in your Python code. The execute_python_code tool in our system can run any valid Python code, including test functions.

This is something we're considering for future development, so this is a great shout!

To have tests that can be copied or exported into a .py module from a notebook is advantageous for prototyping and reusability.

There are exploratory/discovery and explanatory forms and workflows for notebooks.

A typical notebook workflow: get it working with Ctrl-Enter and manually checking output, wrap it in a function(s) with defined variable scopes and few module/notebook globals, write a test function for the function which checks the output every time, write markdown and/or docstrings, and then what of this can be reused from regular modules.

nbdev has an 'export a notebook input cell to a .py module' feature. And formatted docstrings like sphinx apidoc but in notebooks. IPython has `%psource module.py` for pygments-style syntax highlighting of external .py modules and `%psave output.py` for saving an input cell to a file, but there are not yet IPython magics to read from or write to certain lines within a file like nbdev.

To run the chmp/ipytest %%ipytest cell magic with line or branch coverage, it's necessary to `%pip install ipytest pytest-cov` (or `%conda install ipytest pytest-cov`)

jupyter-xeus supports environment.yml with jupyterlite with packages from emscripten-forge: https://jupyterlite-xeus.readthedocs.io/en/latest/environmen...

emscripten-forge src: https://github.com/emscripten-forge/recipes/tree/main/recipe... .. web: https://repo.mamba.pm/emscripten-forge

any comparisons with https://github.com/quadratichq/quadratic ?

*necessary disclosure, i'm a small angel investor in it but genuinely open to see new approaches

I'm actually a fan of what the team at Quadratic is building. It's definitely the more mature product with a robust Python implementation and a well-designed interface that bridges spreadsheets and code. Their stack appears to be built on Rust, which likely gives them performance advantages.

Probly is earlier stage and more minimalist, but we're tackling the same fundamental problem. Our specific focus is on making data analysis a fully autonomous process powered by AI - where you can describe what you want to learn from your data and have the system figure out the rest.

I can see ChatGPT including a spreadsheet component like this in their chat one day.

Amazing name for this tool.

Glad you like it!

From the Miami colloquialism, "Supposably" could be good for an advanced stats add-on!;)

haha! i'll consider it

Can you package it as a standalone npm component library for embedding?

This is nice, is there a limit to the data set been provided?

Any possibility for google sheets support?

Second this.

I'd consider myself the target audience since I frequently dance around spreadsheets and scripts, but being able to use my tool of choice is a must. A simple table or even a database can't fully replace a full-featured spreadsheet application. They are just not the same thing.

Interesting choice of a screenshot in the README... Manchester United in top four, clearly a hallucination produced by the AI.

Or the AI is a man united fan and is hopeful for a top 4 finish this season :D

This looks interesting! How does Probly handle complex Pandas operations compared to something like Deepnote or Jupyter AI plugins? Does it support custom Python scripts, or is it more of a prompt-based solution?

Great question,

Unlike Jupyter or Deepnote where you write code directly, Probly is primarily prompt-based - you describe what analysis you want in natural language, and the AI generates and executes the appropriate Python code behind the scenes using Pyodide.

The key difference has to be that Probly runs python entirely in your browser using WASM, while jupyter/Deepnote run code on servers.

Disclosure, I'm a founder in the data space[1]

Have you thought about how you would handle much larger datasets? Or is the idea that since this is a spreadsheet, the 10M cell limit is plenty sufficient?

I find WASM really interesting, but I can't wrap my head around how this scales in the enterprise. But I figure it probably just comes down to the use cases and personas you're targeting.

[1] https://www.fabi.ai/

I am also very deeply invested in this question. It seems like the goto path for huge large data sets is text to sql (clickhouse, snowflake) etc. But all these juicy python data science libraries require code execution based on off the much small data payloads from the sql results. Feel free to reach out, what you are trying to achieve seems very similar to what I am trying to do in a completely different industry/usecase.

How about a screen video?

posted one about a week or so ago on my LinkedIn

https://www.linkedin.com/posts/oluwatobiadefami_vibe-coding-...

excellent - thanks!