Noctivagous LLM Wrapper App
BEYOND THE CHATBOT APP FORMAT FOR AN LLM
OVERVIEW
The AI industry took off when a GUI chat interface was attached to an LLM (GPT3). A straightforward and easily understood convention for interacting with an AI provided the crucial gateway for everyone outside the field to see what AI was all about. Looking at what this chat app is though, compared to the power of the AI, the front end is a very small amount of technology, a very thin layer of web pages and scripts. Yet without it, what would people be doing today in AI? So the next question is, since it is so essential, why has its role been so undervalued and why it is never the focus of discussion? It provided the way to showcase AI's implications, unveiling the future lying behind that language model that previously only programmers could access. It made OpenAI's reputation among the public. Yet AI companies have not attempted to expand its range and they have not recruited app developers. They are entirely focused on improving the models in incremental updates.
In the last year, this basic chat GUI app software format became a fixed concept for trying out and making use of an LLM within AI research– despite offering only a minimalist set of features, a prototype stage in traditional app development. Wishful thinking has prevailed that the field of AI has transcended the need to pay attention to earlier principles adhered to when making a traditional app, what leads to a finished product. As a result, everyone knows that an LLM is impressive but also is waiting for the next thing. It’s really that important work has not been undertaken. All that has been learned in the last few decades to make quality software was thrown out as obsolete because the gigantic LLM text machine could understand anything said to it via chat. But without a proper interface, it wouldn't have said anything to anyone and this aspect still needs a lot of attention. How could a basic chat app interface be the foundation for an entire technology industry in 2024? The public has reacted accordingly and is now uninterested in AI due to the inadequate software experience.
Without attaching any chat interface to the model’s API it is useless to most people, so why not put a substantial amount of investment money into this aspect when there are hundreds of millions dollars spent training the model? The web chat interface to an LLM, as successful has it has been, would normally just be regarded as the first stage before a traditional software company proceeded to build out a complete suite of front-facing software tools that wrap around the LLM’s generative capabilities, unveiling other facets of the LLMs by providing alternative interactive methods to form prompts just to give an example. It could certainly offer alternative presentations for the output. To give a specific example, it isn't even possible to collapse the containers for the LLM's individual text responses or clear them out of the way when they are unwanted. When the output is unsatisfactory there is no way to hide or delete it.
For input, there are other approaches available in the history of app development besides typing out words character by character. There are alternative views of data available besides a scrolling, vertical list of AI replies. While it is true that the LLM accepts complete free-form sentences and goes far beyond previous computing technologies in this respect, the LLM app developer shouldn't necessarily ask the user to type out sentences to use the AI all the time. Nor does the LLM even require complete sentences in the prompts. It’s actually the opposite, that it accepts all kinds of input formats, whatever the developer tells it. This shows that much variety among front-end apps could exist for interfacing to an LLM besides this simplistic “chatbot”. Other, more succinct forms of instructions exist in software already and they can be adapted to an LLM so that the interactivity is not so laborious. In some cases a person wants to write out full sentences for an AI but in many interactive apps it wouldn't be necessary.
If the situation were more balanced in terms of pairing traditional app developers with AI researchers, there would be another step of evolution in app software for interacting with an LLM, something going beyond this quasi-chat. It might begin with a GUI software method to make prompts rapidly through keyboard shortcuts. The prompts would make sense when read on screen as GUI elements but they wouldn’t necessarily exist in the form of complete sentences or paragraphs received by a human in an e-mail. There are plenty of techniques for making a GUI that generates prompts compatible with an LLM that also don’t require the user to type out everything from scratch as a full sentence each time, something fatiguing for everyone and also rather odd for an entire industry to rely on exclusively when testing out and experiencing AI. This might involve, for example, providing pre-made building blocks that line up one after another inside the text box that are assembled in real time by the user with the keyboard shortcuts. Provided the setup has been crafted enough, these prompts wouldn’t be tiresome to put together like the current requirement of writing out complete sentences for the AI, treating it as if it were human. The situation would become even better if these building blocks were presented to the user in the app in an organized way, as predefined templates placed in categories.
What is currently interfaced to the LLM is disproportionately small, like a garden hose for a giant, olympic size swimming pool. So while everyone can sense there is a lot of potential in any LLM, none of it can be tapped except as a trickle. A chatbot front-end is a miniscule interactive format compared to what the LLM has been trained to provide. It is an incomplete and limited workflow. The point of mentioning this is how little investment money it takes to improve the situation when enormous amounts of money are needed to train the AI before the next one has to be trained.
In the chatbot format, after all of the typing out has taken place for the machine’s sake, a person does feel like his writing effort has been wasted after formulating complete sentences for nobody– a machine that remembers nothing and cannot appreciate that so much work was put into crafting a single AI instruction. As we have said, the prompt doesn’t even have to be assembled that way in software. Given how much money is poured into training these models, there is no reason the AI community should avoid this issue. So much front-end potential has been overlooked as a result of everyone staying inside the chatbot format. So much potential has been wasted as a result of everyone remaining unaware that a chatbot is, in app development, nothing but prototypal and bare when compared to the training time and computation put into an LLM.
The public’s indifference to ChatGPT after the hype wore off should at least be noticed as needing something more than training an even more advanced version of the model. The primary cause is that the chatbot interactive format has no future for the success of AI because its software is too sparse. At the same time, it takes an app developer to point this out and may not be something the typical AI researcher would recognize.
How would a person use an LLM on a touchscreen tablet computer without ever typing on a keyboard (would it be navigating a cloud or tree of touchable labels?). This is a way to break out of the notion that the chatbot app format is synonymous with interacting with an LLM in front-end software, because in reality any number of conventions in software can interact with the API.
THE APP
The objective of this future (web-based) application is to build out a more complete app experience.
This app will expand the number of GUI controls and conventions for
1) formulating prompts
2) interacting with the generated chat responses.
Compared to the bare chatbot format, this app should provide the user a broader range of tools that interface to AI.
STOCK TEMPLATE COMMANDS
First, the chat prompt input area will no longer be limited to typing out prompts from scratch each time. To the left of the text input box will be placed a panel with a list of stock template commands for prompts. Once a command is clicked on, this will insert the phrase or keyword into the chat prompt input box. This gives the user some direction from the outset instead of just an empty text box. What will be inserted into the box by clicking on a command is a graphically encapsulated keyword (for a reference, it should remind a person of Apple’s NSTokenField UI objects).
Example template commands include the commonly used SUMMARIZE: [TEXT] but also EXPLAIN: [TEXT], SUGGEST ADDITIONS FOR:[TEXT], SUGGEST MODIFICATIONS FOR:[TEXT DATA], MAKE OUTLINE OF:[TEXT] and COMPARE [TEXT] WITH [TEXT]. All of these will be available for insertion as graphically encapsulated terms. There are many commands type out for AI chatbots that recur in their sentences and they are categorizable. But until now they have not been collected and then provided to the AI user in an app suite to serve as entry points for interacting with AI. These are what will be included in the stock template library. At a later point users will be able to add their own as well. The template command COMPARE [TEXT] WITH [TEXT] allows comparing details of two similar products found online, to give a specific usage example.
Should the output of that comparison be in paragraph form or a table? The user can decide in advance by selecting the format of the output response: [TABLE, LIST, PROSE]. The (checkbox) controls for this are placed next to the text input area. Should the response data be TXT, HTML, RTF, or JSON? The controls for this setting can be accessed from the text input area as well.
MODIFIABLE CHAT OUTPUT FOR REVISING AND FEEDING BACK INTO AI.
A chat response will not just be static text for the Control+C operation but instead
In addition, a chat response
Instead of just watching every response pile up as part of a long, scrollable list of chat responses, the user has other options for working with the AI output. He can remain with and revise a single AI response repeatedly, as mentioned above. For this there will be interface options to edit the text that was generated and apply prompts to it. This adds a small requirement that there is an undo manager attached to each chat response after it is modified.
THE PROMPT INPUT BOX AS A LIST
The prompt area in the app should resemble something like an Automator script (the 2005 Mac OS X program) in which configurable GUI components are stacked in a list. So instead of just text and an image attachment which is the current setup, a prompt may have more than one component included in it. So for the user there will be provided the ability to append multiple text area input boxes within the prompt input box. That is to say the prompt input box will be an empty holder for a dynamic list, with multiple data types available for the user. (This allows an extensible setup for the future for adding more data types.) To begin with, data types will include:
Stock template command
Text area
Image
An example list:
[COMMAND] + [TEXT AREA] + [COMMAND] + [TEXT AREA]
Through the use of keyboard shortcuts or clicking on [TEXT AREA] and the stock template commands, the components will be inserted right away into the prompt input box. This is the key difference from Automator which is that the components to be inserted into the prompt input box will be inserted with a click or a keystroke instead of being dragged.
(As an aside, it is the goal of Noctivagous in the future to replace conventional dragging in which the mouse button is held down with key-click UI dragging, in which two keystrokes establish the source and destination.)
BETTER CONTROL OVER INTERACTION WITH THE LLM
With this app the user should be able to more effectively shape prompts, access stock prompts, reshape the output given by the AI, and immediately download the output in the desired file format, the one that is best for its destination. The entire chat sequence can be downloadable as a PDF, Word file, or HTML file, which will facilitate later utilization of the AI output
By providing a collection of revision tools in-line for engaging with an LLM, the AI is utilized as a tool rather than an interlocutor.
At the tail of each chat response will be a set of controls for making revisions or relevant follow-up responses, such as “REVISE OUTPUT to Include [TEXT] AND/OR Exclude [TEXT]”. The AI itself will be instructed to provide suggestions for follow-up responses that the user can click on.
The general chat settings will also include omitting any introductions and conclusions. Modes include generating output that does not contain any lists and is only prose. By controlling the output of an LLM and using tools that can make use of it, this very broad technology can be experienced more powerfully than the current, plain interactive chatbot format.
In the future it will be possible to provide use cases as a library of premade configurations of the app, much in the same way that users of a page layout software application are provided page templates so that they don’t have to start from scratch each time.
LAYOUT OF INCOMING AI RESPONSES
To begin with, the first requirement when building this app is that the tokens as they come in are placed inside a multiple column layout (like a newspaper or magazine) so that little or no scrolling is required to read the output.
The quantity of text output in the response will be controlled with a slider control, sitting next to the text input box, that ranges from “paragraph” to “multiple pages.”
Eventually the GUI control containing data that provides the AI its prompts will not be limited to a text UI control but instead will include larger, premade units like building blocks as well as patches (as in node-based programming’s patches). The user would be allowed to choose which way to communicate with the LLM: typing with text (with convenience functions and templates nearby), building blocks, or patches.
1) The AI (LLM) will be treated principally as a tool requiring lots of custom software interfaces to access its capabilities instead of (currently) an interlocutor that carries immense capabilities as a tool (e.g. ChatGPT) that are only acknowledged secondarily to the format of chat. The situation is rather bare and they are available only in minimal amounts in terms of software interactivity.
2) Since the LLM is utilized as a tool first, whatever interacts with the AI will need to feature multiple facets for accessing its capabilities, providing many conveniences for the user rooted in traditional software workflows.
If possible it is also a goal to help the user feel the vast scope of the LLM’s contents so that he or she recognizes that it contains an immense amount of accessible knowledge in all domains that the researchers found training data. This will involve a second set of objectives relating to incorporating features of taxonomy.
The chat input box is placed at the top of the window instead of the bottom. It will eventually allow insertion of rich text, including tables and coloring of computer code. It can expand to the height of the viewport (the browser/window height).
.
The text area that contains a chat response can be changed back and forth from static text (as it is everywhere today) into a text editing control so that the user can make successive transformations inside the chat response and get the outcome he or she wants. The person may edit the response then apply another AI operation to the text and so on. Accordingly, there is an undo manager attached to each chat response box, a history of changes, so that the user can go back. When the user is finished, the chat response, existing fundamentally as a notebook clipping at all times, can be moved to a bin inside the app, it can be e-mailed, etc. or downloaded in any format for permanent storage. Each chat response notebook clipping has a download control with options for download format so that this does not have to be the same as the contents of the chat clipping itself.
For each response, the AI is asked to make a list (which is placed inside a dropdown menu) at the end of each chat response with five possible follow-up requests, and this allows context-specific operations to occur by the user. In the UI beneath each chat response is a standard set of operations for follow-up requests as well.
- A menu appears at the bottom of every chat response
allowing the user to modify the original prompt
or respond to the chat. This includes the AI-generated modification prompts provided inside the response that are specific to it as well as the standard ones.
-- Rectangular building blocks components replace typewritten
prompts. Each component contains GUI controls for its parameters
and is around 200 pt x 200 pt. When there is more than one they
flow like text. A prompt is made out
of one or more of these building blocks.
Each building block makes up the prompt, allowing rapid
construction of parametric prompts rather than just verbal ones.
The container for making a prompt out of these components
can be made as large as a page.
-- The AI itself can be requested to make relevant prompts
and this will be incorporated into the app.
- Export contents of selected output control
to document, .RTF, .PDF, .TXT, .CSV, .XLSX.
- AI-generated tabular data appears as interactive table
in the app.
- AI-generated map data appears on an interactive map.
- Print selected output control.
- Functions for reformatting data output are provided.
The purpose is to provide keywords that are generic enough that they apply to a multitude of circumstances.
CONTINUE: [PASTE AREA]
EXPLAIN: [PASTE AREA]
REACT TO: [PASTE AREA]
COMPARE: [PASTE AREA 1] TO [PASTE AREA2]
COMPARE: [TABLE CONTROL WITH PASTE CAPABILITIES]
EXPAND ON CONTENTS OF TEXT:
SUMMARIZE:
SUGGEST MODIFICATIONS:
SUGGEST ADDITIONS:
MAKE VARIATIONS OF: (such as for paraphrasing but not limited to this specific case)
VERIFY FACTUALITY:
CHANGE [TONE/VOICE/PERSPECTIVE]:
LIST INSTANCES OF [PASTE AREA] FROM:
MAKE OUTLINE OF:
MAKE SUGGESTIONS FOR HOW TO CARRY OUT:
suggest the beginning steps of the first part to carry this out
Make up specifics
OUTLINE THE STEPS [TO CARRY OUT]...
MERGE WITH [PASTE AREA]
PROVIDE PLANNING [HOW TO CARRY OUT A CHORE OR TASK]:
DIAGNOSE PROBLEM:
SUGGEST SOLUTIONS FOR PROBLEM:
CONVERT:
MAKE ANALOGY FOR: [PASTE AREA]
RELATE [PASTE AREA] TO [PASTE AREA]
CONTRAST [PASTE AREA] WITH [PAST AREA]
GENERATION
Make a template for
FILL IN THE FOLLOWING [e.g. html] TEMPLATE [PASTE AREA FOR TEMPLATE] WITH THIS DATA [PASTE AREA FOR DATA]
ANALYZE AND APPLY HEADING STYLES TO THE FOLLOWING TEXT [PASTE AREA] [ [X] WITH FONT: [Arial] ]
OMIT
INCLUDE
EXCLUDE
RESPOND WITH SOLUTIONS [FROM ONLINE FORUMS]
RESPOND WITH SOLUTIONS [FROM ANCIENT TIMES]
PROMPT REVISION FUNCTIONALITY
- Qualities: add [more or less] of [quality].
// Order of array contents matters for each stock prompt command because
Compare PasteArea1 With PasteArea2 is four separate objects in sequence.
promptKeywordCommands = [{
Compare = {[ {“CommandText” : “COMPARE”}, {“UIControl” : “TextAreaRichText”}, {“CommandText” = “WITH”} {“UIControl” : “TextAreaRichText” }]},
etc.
]
RICH TEXT CONTROL
TABLE CONTROL
PLAIN TEXT CONTROL
CODE EDITOR CONTROL WITH HIGHLIGHTING
[ ] RESPONSE IS HTML WITH RELEVANT HYPERLINKS EMBEDDED THROUGHOUT
[ ] MAKE LIST OF REFERENCES WITH HYPERLINKS AT BOTTOM
EMBEDS OF AICHATPROMPT:// HYPERLINKS THROUGHOUT TEXT ALLOW THE USER TO CLICK ON WORDS, PHRASES, AND PARAGRAPHS CHOSEN BY THE AI THAT WILL EXPAND ON THOSE TOPICS IN A SEPARATE CHAT RESPONSE.
MAKING THE LLM GO MAINSTREAM
A Versatile, Fully-Developed, General Use
Software Application Suite
Acting As An LLM Wrapper Is How
Current AI Technology Can Finally
Be Adopted By The Public
noctivagous.github.io
The potential and utility of an LLM is still hidden.
A much more developed category of wrapper app for an LLM
should be the priority of the AI community, one that goes
beyond the basic AI chat format in which the user is
given a free-form textbox and responses are stacked vertically.
Interacting with the LLM is confined to typing out prompts from scratch
each time; there is no developed workflow for modifying
prompts, crafting them parametrically, or viewing the
output in different views or presentations. There are
many uses for an LLM but the user is supposed to reduce
them into a text box. Whatever comes out is supposed to
suffice if it is just a stream of text, a chat response.
Few genuinely sophisticated features have
been provided on the front-end to serve the end user,
at least by the major AI vendors.
The new user is placed in front of the text box and then
told, "Now go! Ask for whatever you want!" which sounds great at first, like an opportunity to interact with a genie in a bottle. In reality, instructions for work jobs are more complex
than discrete and simple requests made out of sentences. They have
parameters, settings, modes that surround the request the person
is making. In addition to this, the person should be surrounded
by available resources such as the images, documents, and snippets
of text he wants to make use of with this machine.
Current AI technology cannot succeed by way of simplistic chat-formatted responses
generated from an LLM. After all, in the workplace a person is provided
a complete document of specifications to carry out a job, not just a few sentences.
The analogue to this for an LLM would be a set of parametric components,
settings, controls, and areas for stored resources that can be included in
the queries. The queries themselves need to be made in different ways,
whether it is typing them out or wiring them up.
The "genie in a bottle" format in which the person gets a wish
granted with a sentence, its response format in which the person
clarifies or corrects the response provided is limited and
contrasts with the natural condition of everyday life in which a
set of commands comes in structured, in bulk, and may (as in the
case of specifications) have charts and other non-verbal descriptions
of the demands.
When you want something complex done do you tell a person who doesn't know you
just one line or a few sentences? Will it all be verbal information?
No, you send them a document with detailed specifications and it may have
a table included. So the LLM has to be able to receive
commands in all kinds of ways and the only way to do that is to provide
a complete suite for input settings, input methods and output setting
and output methods. What should be part of any query would be
a bundle of things and the app makes this possible.
The small LLM text box amounts to a prototypal, unfinished situation
in which the user laboriously starts from scratch each time to compose
short prompts, writing instructions out all over again for every minor tweak
when something wasn't quite right, writing paragraphs of prose and
complete sentences for every revised interaction. Because the LLM
might not provide what was wanted the first time, revisions and tweaks
are inevitable for everyone. It's all too exhausting and incompatible
with mainstream adoption of AI.
To surpass the limitations of the AI chat format,
this future app should seek to provide an application suite
of prompt-making functionality, crafted by the product makers
in accordance with how people generally end up using (or could use)
an LLM, divided into modules or categories inside the app.
Categories and app sections can include the following.
The first is the most freeform. Each category, when activated
displays a collection of specialized controls and functionality
specific to that category. For dealing with text,
common text software tools are built into that mode or section
of the app, something of value to many scholars.
1) (Default Mode) - Continue / Comment On / Make Response to (provided text).
2) Inquiry/Explain a Subject - Generate a profile or background on a topic.
Provide reading list for subject.
3) Manufacture / Generate - literature, poem, essay, possible business names, recipes, etc.
4) Programming / Code - Templates, Generate Code, Evaluate Code, Rewrite Code.
5) How-to (How to Do a Thing) - Solutions for a Problem. Practical Skills. Everyday
Reference. Domestic chores.
6) Veracity Check - (find out if something is true generally).
7) Work with Texts - Explain provided (especially older) text. Translate. Dictionary word lookup.
Text passage origin / its meaning / summary. Extract summary of only
certain type of information from the document.
8) Data: Generate or Retrieve (e.g. avg. weather for a region). Reformat operations for
provided data. Check for a condition inside provided data/text. Analyze.
9) Converse or Simulate Interaction: role-playing, simulated interviews,
language learning, and other interactive sessions designed to mimic real-life interactions.
10) Education/Reading: Provide typical course curriculum for a subject.
Provide reading list. Describe prerequisites for taking up a subject.
Make quizzes, tests.
11) Proofread / Copyedit / Rephrase
For any activity that makes use of an LLM there
will have to be uses crafted for them. The "Work with Texts" will
reflect what people do when they work with texts. This is not
an automatic thing.
----
OPERATIONS FOR AN LLM WRAPPER
Common operations would be EXTEND, which is to take
existing input and go further with it. REVISE.
EVALUATE ACCURACY.
----------------------------
Provide the LLM wrapper a YouTube URL
and it will summarize the transcript.
----------------------------
--- SETTINGS IN THE UI ---
PARAMETERS, BUTTONS, AND CONTROLS.
CURRENT OUTPUT MODE: [RTF] (HTML/PDF/TXT)
OUTPUT RESULTS OF QUERY:
- to a table
- to a code text box
- to a web page
STYLE THE RESULTS
- with headings
- body text font: [Times New Roman] (14pt)
- heading font: [Arial] (Bold) (18pt)
EXPORT RESULTS AS
- spreadsheet
- csv
- html
- json
CONVERT
- [json] to [xml]
- [html] to [rtf]
------------------------
--- BINS, HOLDING AREAS ---
--- Separate, stationary holding area for documents to be used in queries
--- Separate, stationary holding area for pasted text snippets to be used in queries
--- Separate bin for images made part of queries
----
FETCH AND FORMULATE REPORT OF IMAGES, GALLERIES
It might be easy to overlook that at the current stage the
LLMs have not been set up to fetch images from the web
in response to a query on a certain topic and place them
in context of the query. Let's say that a person wants to
research edible mushroom plants. There will be many websites
that provide information about them but this will take a lot
of time to go through them to get a complete overview, perhaps.
There would be value in having the AI compile
a report about the topic that is complete with images,
captions, and so on, from multiple websites, not for the
purpose of re-publication but for providing the user
an overview on a less known topic that might be somewhat unpleasant
to research on the Internet. "What are all of the different
types of edible mushrooms grown for cooking meals?" would
return a list of images and captions. Optional would be
a summary next to each mushroom type. This is beyond what
Google provides at the moment.
AN IMAGE REMINDING THE USER OF THE VAST AMOUNT OF INFORMATION
CONTAINED IN AN LLM AND THE MANY CAPABILITIES.
One of the issues of leaving interaction with an LLM at
a simplistic chat text box is that the user is not in
touch with what the LLM provides. Within the AI community
there are many criticisms of the LLM but no matter what
these could be truly useful bases of knowledge and profound
tools if they are provided the right interface and the
right indications that they are massive, they are thorough,
and they are capable. One does not get this impression
when clicking inside the text box and then getting a response.
In this way too much is left on the user to figure out.
An LLM is so versatile but the barrier to its mainstream
adoption is the fatigue produced by typing out prompts each time,
the lack of organization, structure and guidance provided by such a simplistic user interface,
and the lack of output formatting. So, the AI community should produce common tools
that address this, providing a kind of notebook (sections of generic use
categories), allowing the user the opportunity to select how it should be
used when approaching it.The user approaches the LLM with a text box today
but will instead walk up to adeveloped suite of options. The goal
should be to allow the user to produce the prompts rapidly by providing him or her
with parameter controls. Each category provides its own
premade parameters and settings, setting up a kind of mode
for interacting with an LLM. Mode #7, text mode supplies software
features and workflows will be specific to that category.
An application suite is what will allow AI in the form of an LLM to
be of value.Put differently, we who use them are just those who are
willing to put up with such a basic situation because we are accustomed
to rough edges from technical problems.
The interface for an LLM should be multifaceted, not limited to what the
user can come up with inside a text box. A text box is a prompt for the user to
come up with something impromptu. But our app is a
presentation of pathways for any user who opens it up.
Each pathway, each destination has its own utilities built in.
For this reason, it is conceivable that a person would spend all
day in our app interacting with an LLM.
When the LLM is made use of for reading old texts, for example, it has traditional
software functionality provided for that purpose, for paginating what is pasted,
for treating a PDF as a book that has pages that can be flipped or
laid out as an imposition (overview) sheet, for highlighting text, etc. This is
in contrast to the AI chat that has little recognition when any common,
specific usage occurs apart from writing code, which is when it will
provide a code box.
Allowing the output of an LLM to break out of a vertical chat format
is important as at times there may be value in generating
responses on a grid flowing from left to right, to see iterations.
It just has to be emphasized that if an LLM can generate all kinds of
data, then the means to present that data and generate it should be varied.
If the LLM is used to generate specific kinds of data, the presentation of
the generated output should adapt, just like described,
so that it isn't always raw text stacked vertically. If it generates
chart data, the data should show up in a chart. If it is a quiz being
generated, then ideally an actual set of quiz controls should show up
in the response. A recipe should be formatted as a recipe card if possible.
Shaping the LLM's output presentation will make these very expensive
AI models valuable. When AI is viewed as a more advanced tool rather than a
simplistic genie in a bottle paradigm in which a question is asked an an action follows,
these goals will be discussed more often. Tech often gets ahead
of itself, wants to be more than it actually is and obsolesce the present
to feel like it is moving into the future. But the basics of
traditional software remain.
NOISE IN DATA IS COMPRISED OF...
-----
1) Continue/Comment On/Make Response to: This would enable users to
build upon or have the LLM respond to existing text, whether it's their own or
provided by the LLM. There are dialectical benefits for
the user of the LLM in this module. There is the ability to see
a broader view of the topic by having the LLM response.
2) Inquiry/Explain a Subject: Users could utilize the LLM
to research and generate informative profiles or backgrounds
on a wide range of topics, as well as receive curated reading
lists to further explore those subjects.
3) Manufacture/Generate Text: This would allow users
to generate various types of written content,
from literature and poetry to business name ideas and essays,
based on specified parameters or prompts.
The LLM could draw upon its broad knowledge to produce
high-quality, original text tailored to the user's needs.
4) Programming Code: This section would enable
users to leverage the LLM's capabilities for
software development, including generating code,
answering programming-related questions, and
even performing various code operations like
refactoring, optimization, or debugging.
5) How-to and Solutions for Problems: This feature would allow users to
obtain step-by-step instructions or solutions for a variety of
tasks and challenges, drawing on the LLM's extensive knowledge
and problem-solving abilities. Especially relevant to household
tasks, home improvement, automotive repair, questions about
machines, appliances, etc.
6) Veracity Check: Users could use this feature to assess the
truthfulness or accuracy of claims, information, or statements,
leveraging the LLM's understanding of factual knowledge and its
ability to cross-reference sources. Primarily valued for
circumstances relating to factuality outside of contemporary
controversies.
7) Explain Provided Text: Users could leverage this feature to gain
insights into the origin, meaning, and context of a given text,
helping to deepen their understanding. Especially useful for
older texts. Translation, summarizing, etc. for provided texts
falls under this category.
8) Data Generation and Analysis: The LLM could be used to generate,
format, and analyze various types of data, from weather forecasts
to statistical insights, providing users with valuable information
and insights from data.
9) Converse, Simulate Interaction: This section would allow users
to engage in more immersive and interactive experiences, such
as role-playing, simulated interviews, and language learning
exercises, helping to bridge the gap between the LLM and real-world interactions.
10) Education: The LLM could be utilized to provide information on typical course
curricula for different subjects, as well as describe the prerequisites and
other relevant details to support educational and learning goals.
Test questions and quizzes can be generated in this section.
11) Proofread / Copy edit / Rephrase For Editing
Consider that conventional web search engines are
limited in the same way, that often there is an inclination on the part of the
user to make web searches carrying more specific conditions
but there are no settings on the search page that
are provided for this for fear that it would make using
the web search engine too technical. But when a web search
is made, sometimes there is a desire to
limit the results to entities in the physical world, to
make sure that results exclude Internet entities.
Often there is a desire to limit a list of these results further
to a geographic boundary, too. Web search could be said to be in
the same state as the LLM chat format, something simplistic.
Just like an LLM, there are possible categories of usage that
won't make it difficult for a lay user
to use the technology. But because of an online culture
that seeks to make everything minimalist, the potential of many
technologies is obscured. Minimalist is pursued as an ideal,
to the detriment of usability and completion of the software needs.
Even when you instruct humans you give them long spec sheets
and documents with bullet lists. "Genie in a bottle" commands,
making consecutive small requests to the AI, isn't broad enough for
the AI to be of value for everyday tasks. The AI tool
has to be able to take in a blueprint all at once and
the parameters of this have to be easy to change.
---
BUILDING LLM PROMPTS
-- Rectangular building blocks components replace typewritten
prompts. Each component contains GUI controls for its parameters
and is around 200pt x 200pt. When there is more than one they
flow like text. A prompt is made out
of one or more of these building blocks.
Each building block makes up the prompt, allowing rapid
construction of parametric prompts rather than just verbal ones.
The container for making a prompt out of these components
can be made as large as a page.
-- The AI itself can be requested to make relevant prompts
and this will be incorporated into the app.
STANDARD APP SOFTWARE FUNCTIONALITY
- Export contents of selected output control
to document, .RTF, .PDF, .TXT, .CSV, .XLSX.
- AI-generated tabular data appears as interactive table
in the app.
- AI-generated map data appears on an interactive map.
- Print selected output control.
- Functions for reformatting data output are provided.
PROMPT REVISION FUNCTIONALITY
- Qualities: add [more or less] of [quality].
CHAT OUTPUT TAIL MENU
- A menu appears at the bottom of every chat response
allowing the user to modify the original prompt
or respond to the chat.
---
In an app like this, menus divide interactivity with the LLM into
categories that assist the user in generating prompts according
to the needs when the LLM is used. Providing starting points for the LLM
for the user will end up being far more productive than a bare text box, which
is probably too simplistic and tiresome when there is
such a wide range of situations for which a person might use an LLM
and such a large number of instances when the prompts could be
formulated with convenient, traditional app user interface.
At the current time, this is not regarded as a concern as there is
belief that AI technology is advancing so rapidly that the tool
just described will be obsolete as soon as it is finished in a year or
two. That may not be true.
A weak point of the AI chatbot is that interacting with the LLM
often involves a lot of repetition and revision of writing and typing
but there are no functions provided for that or even something to
formulate prompts generatively in the first place.
The presets within each category will facilitate valuable
usage of the LLM for that individual category.
An LLM wrapper app like this demonstrates product development
that extends beyond the basic AI chatbot because it works with
the LLM with more developed interactive conveniences and it shows
that product is not obsolesced by research and engineering but
should continue to be discussed.
Currently the textbox for an AI chatbot is freeform typing.
Offering some organization and structure to the situation--
laying down a kind of blueprint for the amusement park--
will make the LLM a lot more useful for the consumer.
It is only under these conditions when an LLM could
become mainstream.
---- GENERATE META INSTRUCTIONS FOR EXERCISE, QUIZ, ETC. ---
A paraprogram that structures responses from the LLM
in a stateflow so that it is back and forth.
The meta program routes the output in a flow chart
for the correct answer until it is given.