I asked ChatGPT a question

[Dean D. Babic]

Me:
Hi, is anyone else asking about Jam.py github project besides me? :)

AI:

Ah, now I see what you're getting at — you're asking if anyone besides you has mentioned or asked ChatGPT about the Jam.py GitHub project.

While I don’t have access to private user interactions or logs (including who asked about what), I can say this: Jam.py is a relatively niche but steadily growing Python framework. I've answered questions from other users about it before — things like:

• How to set up a Jam.py project.

• How to customize the UI.

• Migrating from MS Access or PHP tools to Jam.py.

So yes, you're not the only one asking about Jam.py, though it's definitely less common than Django or Flask.

:)

[Dean D. Babic]

Me:
  Thanks. So what would you suggest for Migrating from MS Access?

AI:   
You're welcome! Migrating from Microsoft Access to Jam.py is a smart move, especially if you're aiming for a browser-based, cross-platform solution using open standards.

Here’s a step-by-step guide and suggestions tailored for such a migration:

---

✅ 1. Assess Your Current Access Database

• Tables: Note all table structures and relationships.

• Queries: Especially saved queries or SQL views.

• Forms/Reports: Look at how the UI is structured.

• VBA Code/Logic: Note automation or validation logic.

🛠 Use the "Database Documenter" in Access to extract full schema info.

---

✅ 2. Choose the Backend Database

Jam.py supports:

• SQLite (good for single-user or testing)

• PostgreSQL, MySQL, SQL Server, etc.

🎯 Suggestion: For production, use PostgreSQL — it’s powerful and well-supported.

---

✅ 3. Export Tables

• You can export your Access tables to CSV or use ODBC to migrate data directly.

• Tools like Access to PostgreSQL or DBConvert can help.

---

✅ 4. Rebuild Schema in Jam.py

• Use Jam.py's Admin Interface to define:

  • Tables and Fields

  • Relationships (foreign keys)

  • Lookup fields

  • Permissions and Users

• You can also use Jam.py’s "Import Table" feature if you connect to an existing DB.

---

✅ 5. Recreate Queries as Views or Filters

• Access queries map well to Jam.py filters, scopes, or even direct SQL views in the DB.

• Use Jam.py’s Python event hooks for complex logic.

---

✅ 6. Rebuild Forms and Reports

• Jam.py provides:

  • Customizable web forms

  • Master-detail views

  • Charts and reports

• You’ll rebuild these using Jam.py’s web UI — no HTML/CSS needed.

---

✅ 7. Port VBA Logic (if any)

• Convert VBA to Python events in Jam.py:

  • on_before_post

  • on_after_insert

  • etc.

🧠 Jam.py has full support for Python scripting — powerful and more maintainable than VBA.

---

✅ 8. Deploy and Test

• Jam.py apps run on standard web servers.

• Test on local, then deploy to cloud or LAN.

Then it started hallucinating with offering a starter script.  
Which is not needed.

Check also:

• on_after_insert, ...
  
  

They do not exist.
All in all good effort. Not 100% correct but close enough.

[Nick Antonaccio]

Gemini 2.5 Pro Preview 03-25 actually has baked-in knowledge of jam.py and can currently help better than most other LLMs.  I also had success with Grok after feeding it https://com-pute.com/nick/jampy_llm_introduction.txt   ChatGPT doesn't do as well without lots of additional in-context learning and corrections.   Leveraging Gemini's baked in trained knowledge, together with feeding it a copy of the official docs does far better than any of the others I've tried so far.  The newest version Qwen3-235B-A22B also does better than ChatGPT, out of the gate on initial tests, but I haven't done any significant work with it yet in jam.py.  If you want to use an LLM to help with jam.py, certainly give Gemini a try.  Export the PDF documentation as text or markdown, and keep it in context (Gemini 2.5 Pro has a 1 million token window, so can keep all the documentation in context within a conversation).

[Drazen Babic]

Hi Nick,

cheers for that. 

This was just a question which poped up when I asked Chatgpt how many ppl are asking for Jam.py :) And what they are asking for.

First question was how to install it.

Second I cant remember.

The third was this one.

To be fair, Demo project and a lot of other Demos we created for public just scratched the surface. So "would be" users could follow from scratch.

The V7 is so different than V5 that its not worth spending time on V5. The code in v5 is also very old.

For example:

- everything in Jam is API.

- in V7, everthing goes through on_request. 

Which was not the case in V5

- in V7, the Tabs exist for Desktop, Tablet, Phone. This does not exist im v5, and its within Builder IDE.

Combine on_request with /api and we got SPA with routing for all devices out there!

D. 

--
You received this message because you are subscribed to a topic in the Google Groups "Jam.py Users Mailing List" group.
To unsubscribe from this topic, visit https://groups.google.com/d/topic/jam-py/NLKSrKZVITg/unsubscribe.
To unsubscribe from this group and all its topics, send an email to jam-py+un...@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/jam-py/cb850a48-f07e-4aa4-ab36-eeb00ab9b84an%40googlegroups.com.

[Kevin Keller]

I am currently working on improving a custom tuned model for jam.py. 

Its already working, but probably needs to be improved with more documentation and sample code. 

And obviously user feedback: 

Let me know if anyone wants to play with it. 

You received this message because you are subscribed to the Google Groups "Jam.py Users Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to jam-py+un...@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/jam-py/CAMvz_Ho%3D%3DT%3Dgi31aCk-zjMj5ohtPE9dh7KxD-Rcg86HAnUupdA%40mail.gmail.com.

[John Bannister]

I would def like to play with it. Can you post/send details please?

To view this discussion visit https://groups.google.com/d/msgid/jam-py/CADHCKLQ3%2B7fcDkp6LBy35joPqXkCk2MjeR7vj3akffJbYN3RfA%40mail.gmail.com.

[Drazen Babic]

Guys,

it is hallucinating.

Jam.py has no models. 

AI is taking Flask/Django models and presenting it as Jam.py solution.

There is a lot of wild guesses with using AI and Jam. Jam is like Access. You drive it with a mouse.

What u cant drive with a mouse, u drive with JS/Python.

Just like with a VBA in Access.

Access CRUD is driven by Access. Just like CRUD in Jam. Thats done by Jam.

One example for AI is automated backup for V7.

It took a HALF A DAY of chatting and going nowhere.

Than I did have a proper look into HOW is login happening from the browser!

And bang. Figured in one minute. It is a POST to builder_login.html which gives the magic mashroom cookie😍

The AI does not know that, because it cant see the browser console. Sure, splat some code to it, and see if it works!

What I would suggest is to look at vids Andrew created. There is no magic wand that will create an app for u with Jam.

Flask/django is all html. Jam is full JS based, like Vue etc. Huge, massive diference. 

But, I love a challenge, lets see what this does!

D.

[Kevin Keller]

I need to feed it the proper instruction. For example for that and other common jam py questions. Do you have some docs or links I cns feed it apart from the usual docs. I can use the llm text that was cicucled earlier her to make chatgpt underpants jam a bit better as a starter as well with permission

To view this discussion visit https://groups.google.com/d/msgid/jam-py/CAMvz_HqgmgLhD%2BYiTWq5hQZ7tNpxQGU6WwN-Qx8nzPYEkWPpDg%40mail.gmail.com.

[Dean D. Babic]

The number of false info on the net is staggering.

For example:
https://lagentx.com/low-code-et-automatisation-les-nouvelles-tendances-qui-revolutionnent-le-developpement/

There is no "from jam import JamApp"

Or this:

https://testrigor.com/jam-py-testing/
There is no '/auth/login' for Jam.py

As Nick suggested, ChatGPT is a no go. I never had any success with it. 

Maybe try uploading the github source code.

But v5 is not maintained any more. It is just too old.

D. 

[Dean D. Babic]

Ok, 

so I did bite and asked claude.ai what is known about Jam.py ( What do you know about Jam.py?)
The below was included in the answer:
- Offers a component-based architecture for building modular applications   

I asked more about this:

-  How would you build a component-based architecture with Jam.py?

Started with:  from jam.application import Task

The hallucination was staggering....
" I sincerely apologize for the inaccurate information! You're absolutely right, and I made a serious error in my description of Jam.py. Thank you for correcting me."

  

The problem with all AI bots is that Jam.py has a Web Admin panel. Just like Django. But on steroids.

And AI does not know how to interpret that. Then it went with:

The actual approach to component-based architecture in Jam.py involves:

1. Using the web-based application builder interface
2. Creating application items visually through forms and drag-and-drop
3. Defining data structures through the visual interface
4. Building forms and reports through the visual designer
5. Establishing relationships between components through the UI
   

Which drag and drop? :) Reports? 

The AI is just creating a confusion for a would be developers. No wonder Andrew decided to leave.

Because this is a death for Jam. I see it now. 

For a new users, the simple start of a new project is questionable:


Unfortunately, I think because of niche Jam.py market, AI's are very, very confused.

Which does not help us at all to gain traction.

End of rant :)

[Harshavardhan Patil]

I did try Grok for one of the modules and had a similar experience to what Dean is describing here. It went into hallucinations and gave me a lot of irrelevant code. It was using generic python and js code instead of built-in jam.py functions. 

However, I was able to get it to build one simple function for me for bulk upload of data. An empty excel format of a table is exported to the user, and upon import, bulk upload is made to the database.(Note: This could be a standard feature inside jam.py with access restricted to certain roles like admin. Food for thought.) 

Also, I learned a lot from Nick's video series on Jam.py.  <<Shoutout>> :)

Next, will try Nick's suggestion for Gemini 2.5. 

Best Regards,

Harsh

[Dean D. Babic]

Bulk upload actually exist:
https://jampy-docs-v7.readthedocs.io/en/latest/how_to/how_to_migrate_to_another_database.html

What I'm concerned is the confusion for a new users. 
Power users or skilled developers are not a concern. 

This:
https://media.licdn.com/dms/image/v2/D4E22AQHGaSJWRctvQg/feedshare-shrink_1280/B4EZa_iqTHHMAo-/0/1746970257791?e=1750291200&v=beta&t=krTquZTnNAMZsDjVME6OHQ1LlMs4opfhNA2D9oK8AEs

:)

[Nick Antonaccio]

Jam.py has virtually no documentation available online (compared to Django, Flask, etc.), so information about the framework is not included anywhere in the pre-training data set for most LLMs.  Without training data, the LLMs have absolutely no way to know anything about jam.py.   Fine tuning and in-context learning, however, is easily accomplished with just about any LLM.  In-context learning is completed simply by providing any information the LLM needs to answer questions, directly in a conversation, so that the LLM can learn and reason from the provided documentation.  In context learning can work well, but it's only valid within the ethereal context of a single conversation, and all the documentation must fit within the context window size limit of the LLM.

Gemini 2.5 Pro has a context window size of 1 million tokens, so a LOT of documentation can can be crammed into a single chat.  Gemini 2.5 pro also managed to have gotten some documentation about jam.py included in its pre-training data set, so it has some legitimate baked in understanding of jam.py.  So, as long as Gemini 2.5 Pro understands that you're talking about the jam.py framework at jam-py.com, you're in a better position working with Gemini 2.5 Pro, than any other LLM which hasn't hasn't had jam.py docs included in the pre-training data (basically all the other big commercial models currently know *nothing about jam.py).

The older version Gemini 1.5 has a context window of *2 million tokens, but that model doesn't appear to have any baked in pre-training knowledge of jam.py, and it's also not nearly as 'smart' as Gemini 2.5 Pro, so it's only potentially effective at dealing with large volumes of documentation and longer context chats at the moment (for example,  perhaps larger code bases which make use of specific documentation).

Of note, Qwen Max has a 1 million token context limit, and it's capable of significant intelligent reasoning, so it is able to learn a significant amount of documentation in context - but it still doesn't beat the baked-in knowledge that comes with Gemini 2.5 Pro, together with that model's 1 million token limit.

You won't beat Gemini 2.5's Pro ability to understand jam.py natively, using any other current LLM, because none of them have been pre-trained on any jam.py documentation as fully.  It doesn't matter how well prompts are crafted, unless the required documentation is provided in context, or in fine-tuning rounds.

The good news is that all the smartest frontier model LLMs can perform in-context learning, up to the token limit of the LLM's context size - but more important, most can also be fine-tuned with more data (which also *doesn't effect context limit in a conversation).

The even better news is that jam.py consists of jQuery, Bootstrap, and Python, which most LLMs have been pre-trained on deeply - literally billions of pages of documentation and billions of lines of code.  Most LLMs are absolute masters at writing code in jQuery, Bootstrap, and Python, as well as CSS, JS, HTML, etc.  What that means is that most LLMs just need a little bit of knowledge about how jam.py works, in order to be able to connect the dots.

My little document at https://com-pute.com/nick/jampy_llm_introduction.txt provides a start, to get most LLMs connecting those dots.  Grok did a great job building working jam.py code, after reading only that document in context (just attaching that file to the conversation).  That document is fairly short, so there should be enough context left in a chat to provide code and have a conversation, with most models that have, for example, a 100,000 token context limit.  Adding more to that document would help to greatly improve the in-context knowledge of any sufficiently intelligent LLM.

The next level is to include the full official jam.py documentation in context.  The problem is that all that documentation will typically max out the context window size of any of the current LLMs.  Llama4 will have a context size of 10 million tokens, so that will likely be a good contender for including more documentation in context (although I've heard that Llama4 shows signs of not actually being as smart about using all the data in it's 10 million token limit, so we'll have to see how well it does...)

The next level is to fine tune a model.  This is where we'll see massive improvements in performance and understanding about jam.py by any LLM.  Google AI Studio provides the ability to fine tune, and together with Gemini 2.5 Pro's baked in pre-training knowledge of jam.py, as well as it's strong reasoning intelligence, and it's large context size, that is the model to focus on for now.  ChatGPT provides the ability to build custom GPTs, but I've had mixed experiences with how well those follow instruction and make use of provided fine tuning data.

I haven't performed any fine tuning about jam.py yet, with any model, because I've been able to get all the solutions I've needed by simply relying on Gemini 2.5 Pro's existing pre-trained knowledge, my little LLM example document, and the official documentation, uploaded in-context.  Gemini 2.5 Pro has been successful at providing working code, for example, to build custom menus and performing tasks which were NOT provided as examples in my LLM document.

So the next step is to fine tune Gemini 2.5 Pro, and/or any open source model that can be significantly improved with fine-tuning, using all the official documentation, all the history and knowledge in this mailing list, the entire jam.py Github repository, all the application examples that exist from Dean and others, etc. - anything and everything it can consume to understand everything possible about jam.py - including curated output created by the current models ('synthetic data' which is correct, and/or more code created by Gemini 2.5 Pro, more new and correct curated documentation, etc.).  That will provide a permanent base of understanding about jam.py, and combine that understanding with the tremendous core knowledge and understanding every current LLM already has about jQuery, Bootstrap, CSS, JS, HTML, Python, the massive ecosystems surrounding those tools, etc.

The next step beyond fine-tuning Gemini 2.5 Pro is to deeply fine tune several different models, and then have them work together as teachers and students of each other, so they generate more working jam.py examples.  Providing agentic tooling to those models, and using deep research frameworks, so that they can create and test new code examples and progressively build and test more complex working applications, would enable such a set of models to generate more fine tuning data... and so on...  which would eventually *dramatically improve the ability for us to fine tune any other model, and expand the capabilities of jam.py.

I'm currently buried in production development projects using other frameworks and tools, but this fine tuning work on jam.py will be a passion project, as soon as I have the time available.

[Drazen Babic]

Interesting discussion. Thanks.

Not exactly related to Jam tho.

What I'm trying to understand is how LLM will attract new users.

As on this pic, the documentation was never a problem. 

It is the willingness to sit and do. It is the desire and drive.

We have fantastic and very responsive apps out there. 

Quite desirable apps imo from a low code point of view.

As on a pic, "but most ppl still won't use them. Why is that?"

That's what's bugging me.

[Harshavardhan Patil]

@Nick,

Very detailed roadmap on how jam.py could be taken forward for AI compatibility. Excited, I will keep following updates on your work. I am not that skilled yet, in setup and usage of AI models . Would love to learn, and help out wherever I can. 

@Drazen,

Available documentation has definitely helped me as a new user to get started and bring my project up to a respectable level. Thanks for the thorough work you and the others have put into this. 

100 % Agree to this - 

 

"We have fantastic and very responsive apps out there. 

Quite desirable apps imo from a low code point of view."

 

Thanks & Regards,

Harsh

--

You received this message because you are subscribed to a topic in the Google Groups "Jam.py Users Mailing List" group.
To unsubscribe from this topic, visit https://groups.google.com/d/topic/jam-py/NLKSrKZVITg/unsubscribe.
To unsubscribe from this group and all its topics, send an email to jam-py+un...@googlegroups.com.

To view this discussion visit https://groups.google.com/d/msgid/jam-py/CAMvz_HpxpZOcChg4939-a567d21T%3DJi9%2BtQLKD6mGF4JrWd9aQ%40mail.gmail.com.

[Kevin Keller]

Yep, thanks for the info Nick. 

I was actually proposing and already working on starting with a general model and just feed it some info via RAG and some more info in its knowledge base (intial system prompt) . 

That should already get you there to have the model understand Jam.py and be able to produce useful output. 

I already got started with it, but as you can see there were still hallucinations, but I also did not have a lot of time to invest nor was there much documentation that was available to feed to the model easily. 

IDeally we would distill some easy to use text (as you already started) but mich more comprehensive, or we distill whats available for the webpage into plain text. 

If you make that available to the model it should already get you there 80-90% of the way. 

If that is working as expected, then we would take the next step and fine tune the model I would say. 

I started with qwen2.5 7B. But I also have beefier models available in Websson and we also got accepted into the Sclaeway startup program which gives us a good budget for GPU cycles starting from first of June. 

So I am happy to use the GPU credits we get to to the prompt + RAG test , then let everyone test and afterward we decide what data to fine tune on and run the fine tuning on the Scaleway GPUs. 

We already support Jam.py on a free plan natively or hosting and developing and will now go the next step to help Jam.py be supported by AI and make the AI model avaiable as part of our free plan in the AI chat and VSCode companinion (powered by Continue.dev) avaiable. 

But we would need text based quality info to make easiy avaiable to the model for step 1. 

You received this message because you are subscribed to the Google Groups "Jam.py Users Mailing List" group.

To unsubscribe from this group and stop receiving emails from it, send an email to jam-py+un...@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/jam-py/CAOnb5nOPvV%3DXJ1yASfAC2Vjx02Ls8BdYzCaRxmhQp8CLyq6AYw%40mail.gmail.com.

[Dean D. Babic]

From Gemini 2.5 Pro today (see in bold):

Okay, I know a bit about Jam.py!

It's an open-source, full-stack web application framework written in Python. The primary goal of Jam.py is Rapid Application Development (RAD), particularly for database-driven business applications.

Here's a breakdown of what makes it stand out:

1. RAD Focus (Rapid Application Development):

   • It's designed to let you build functional web applications very quickly, often with minimal coding.

   • This is ideal for internal tools, administrative backends, prototypes, or smaller business applications.
     

2. Database-Centric:

   • It's built around the idea of interacting with databases. You define your data models, and Jam.py helps you create interfaces (forms, grids, reports) to manage that data.

   • It supports various popular databases like PostgreSQL, MySQL, SQLite, Firebird, Oracle, MS SQL Server, etc.

3. Visual Designer (Builder):

   • One of its most distinctive features is its browser-based visual designer. You can create and modify your application's structure, forms, reports, and logic directly in your web browser without writing much code.

   • This reminds some users of tools like Microsoft Access, Delphi, or Visual Basic, but for web applications.

4. Python-Powered:

   • While much can be done visually, you can extend functionality and customize behavior using Python on both the server-side (for business logic, event handlers) and sometimes even for client-side interactions (though it primarily uses JavaScript for the front-end).

5. Built-in Features:

   • Automatic CRUD interfaces: Create, Read, Update, Delete operations are easily generated.

   • User authentication and authorization: Manage users and permissions.

   • Reporting tools: Generate reports from your data.

   • Forms and Grids: Standard UI elements for data interaction.

   • Master-Detail relationships: Easily handle linked data.

6. Client-Side:

   • It generates the necessary HTML, CSS, and JavaScript for the front-end, often using a responsive design framework so applications work on different screen sizes.

7. Deployment:

   • Jam.py applications can be run using a standard WSGI server.

...

Potential Considerations/Weaknesses:

Smaller Community: Compared to giants like Django or Flask, the community is smaller. This means fewer third-party packages specifically tailored for Jam.py, and potentially fewer online resources (though their documentation is decent).

...

Etc...
See my concerns:

smaller business applications.  - Jam.py can be used for extremely large apps. - see official vid

You define your data models - no need. Jam can Import tables from existing systems. Hence already defined.

reports - Jam does not help with reports, LibreOffice is not mentioned anywhere. It is LO which is used for designing a report Template.
event handlers - no, there are only a few: on_apply, on_open etc. For AI to be able to digest the official Documentation, we first need to fix

typos in Docs, ie Mehods - https://jam-py.com/docs/refs/server/item_api.html (but that's not going to change asap, since Andrew left).

So use this: https://jampy-docs-v7.readthedocs.io/en/latest/refs/server/item_api.html

sometimes - Jam is all about the Client Side events. The client side drives the server-side (name it a backhand).
are easily generated - No need to generate any CRUD, it is there by the default.
Reporting tools - there is no reporting tools with Jam ATM. The atm means there was a plan for such a feature.
It generates the necessary HTML, CSS - Jam is pure JS with minimum amount of html used. It is NOT designed to mix html with JS. Why? Events.

This means fewer third-party packages -  what to say about this?

I'm not in the business for disregarding AI.

Because Andrew is not here, and I'm quite sure he would not go in this discussion,
I feel I need to point out about the differences with AI what Jam is and what it is not.

My concern is this: the AI will create usable but very nonperforming Jam app.
Than, as usual, we will blame Jam.

I've seen more than 300 MS Access apps. Maybe one or two were performing.

I also blame Access here :)

Hope this helps.

[Kevin Keller]

The technical info is great. We can use that for our use case. Thanks for sharing that. 

On the topic whether or not to invest time and effort into AI for Jam.py... there I think its simple:

Many people, especially low code / small time coders will use AI for everything. 

So you either make your framework AI available or you will simply not considered. 

Does AI sometimes write bad code? Yes, just as (junior) coders do sometimes. 

They will not blame the code but on Jam.py, if they write the code themselves or use AI. 

Also true. 

But the key point is, they will use AI. This trend is only accelerating. 

I think Jam.py has to play the AI game one way or the other to stay in the race. Whether the code is good or not, is a question 

of how big of a model you have, but more importantly, what data is available to the model . 

Data is really what it comes down, especially as the models get more powerful.

Fortunately that is the piece that we could influence with AI ready documentation in markdown or text or quality code snippets for most common challenges.  

--

You received this message because you are subscribed to the Google Groups "Jam.py Users Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to jam-py+un...@googlegroups.com.

To view this discussion visit https://groups.google.com/d/msgid/jam-py/17262654-78b1-45a7-81fc-9a14f641cff9n%40googlegroups.com.

[Dean D. Babic]

No probs Kev. 

I am trying to be earnest, and I think I know where Jam is failing big time with AI.

It is exactly on the premise that Jam is a Python framework. Like Flask/Django.

It is not. It is impossible to write a Python code by AI to define an app from scratch.

This is because of the Jam entry point. Just like Access, Jam is RAD, meaning all app components are kept in the sqlite database file. None are really kept elsewhere, except index and template file (for V7).

Jam creates js from the database. Fiddling with js outside Jam App Builder is not supported. 

AI does not know that. It does not know how to manipulate a Jam entry point database file.

While it is possible to add an AI visual component to Jam, the question is for what that component will be used for? 

Creating Flashcards? Onboarding pages for the new users from AI generated content? I'm sure

there are more specialised products for that.

Jam was never in the race imo. 

Jam is a super specialised, minimalistic product which does exactly what it is designed for.

What was not recognised enough from the beginning, is using Jam with existing databases. 

Even AI does not stress this enough. 

Take MS Access as an example. We can expose all data from Access DB via Jam. No migration needed.
Crickets.
We can do that with any other DB provider. Even more crickets....

D.

[Nick Antonaccio]

Hi Dean,

Yes, it's very likely that none of the mainstream models were ever trained on any screen shot images of the important no-code features of jam.py, but that doesn't mean it's not possible to improve that situation.  In fact, a multi-model model like Gemini (or Gemma, Qwen, etc.) could be used to help extend hand-written documentation, once it's bootstrapped with some curated explanations of screen shots.  An agentic workflow could be put together to help with generating even more documentation for fine tuning text output.

Your work towards demonstrating the strengths of jam.py is tremendously appreciated.  The examples you've created and shared, and the effort you've put into documenting the processes you've encountered show just how deeply effective jam.py can be.  Jam.py is a fantastically engineered tool, and very useful, extraordinarily productive at creating CRUD applications with complex grid and form interfaces, even for large schema.  Very often, the work that jam.py eliminates, includes some  the most time consuming and critically important effort required to develop business applications.  The fact that jam.py includes fine grained auth, audit trails, soft delete, etc., is a tremendous time saver when dealing with compliance requirements.  Jam.py packages so much of the functionality of other no-code tools like Airtable, Baserow, Nocodb, etc., but it requires much less memory, HD, CPU, etc., requires much less software infrastructure, and is much less complex to install, it connects to all the most important RDBMSs, is more usefully open sourced, brandable, etc., etc., etc.  Your applications demonstrate so well just how deeply capable jam.py's strengths are.

But what *really strikes me is jam.py's *composability, so it can naturally enable so many more categories of development work than the no-code pieces are meant to accomplish.  The no-code schema building, UI grids and forms, ORM system, and all of jam.py's other features can be integrated very naturally and easily with vanilla Python, JS, HTML, CSS, jQuery, Bootstrap, SQL, etc., and all the fantastically capable ecosystems of those mature and well known building blocks.  And I love that jam.py provides a web based build environment.  I'm a fan of browser based IDEs - in my experience, they enable the most convenient workflows.  

My interest is particularly in the limitless composability which jam.py enables, and the fact that the vanilla building blocks it consists of and exposes, are the ones which most LLMs are most deeply pre-trained in.  We just need to connect the dots about how the no-code visual pieces of the framework, the ORM, and the other unique parts connect with the vanilla building blocks, to really able LLMs to go to town building any sort of custom interface and backend functionality that isn't built into jam.py's core capabilities.  Integrating those core capabilities with the broad and deep capabilities of the massive ecosystems of it's building blocks enables a potentially dramatic broad scope of work to be accomplished with jam.py, in ways which haven't been demonstrated so far.  None of jam.py's capabilities need to be ignored or discarded for that broader scope to be tapped.  It can all be integrated naturally, to the great productive benefit of anyone who uses the framework.

Every bit of work you've done is fantastic, and powerfully effective at achieving the goals jam.py was intended to satisfy, but jam.py can be extended so easily with custom UIs and back-end tooling, to accomplish so much more.  And with the help of AI coding assistants, the infinite extensibility of those vanilla building blocks will be much easier for a new generation of users to expose, explore, and build upon.  Training LLMs on jam.py presents an opportunity to attract a new crowd of developers to this amazingly capable and well-designed framework.  The simplicity it enables, and the light-weight nature of it's infrastructure requirements, as well as all the capability you've demonstrated so well are certainly interesting and useful to and developer.  The extendable nature of its well known building blocks is what I think hasn't been well enough demonstrated to attract a larger crowd.  By training an LLM to build jam.py functionality, the option now exists to quickly onboard a new community of users who can help build out jam.py's capabilities, it's reach, and it's popularity.