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.
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!
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.
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.
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 :)
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?
This is something we're considering for future development, so this is a great shout!
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
*necessary disclosure, i'm a small angel investor in it but genuinely open to see new approaches
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'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.
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.
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.
https://www.linkedin.com/posts/oluwatobiadefami_vibe-coding-...