state-of-llm.streamlit.app

What is State of LLM Apps 2023?

State of LLM Apps 2023 is a Streamlit web app that presents findings on how people were building applications with large language models in 2023. The page itself is a JavaScript-driven app, so the substantive content loads in the browser rather than appearing as static text. Treat it as a snapshot report of that year's LLM app-building practices, useful for context rather than for current product specs.

Who it's for and how to use it

• Developers and product teams starting an LLM feature can use it to see which patterns were common that year — for example, whether teams leaned on hosted APIs versus self-hosted models, and which app categories (chat, summarization, agents) were popular.
• Researchers and writers can cite it as a dated reference point when describing how the LLM tooling landscape shifted after 2023.
• Decision criterion: if you need present-day architecture guidance, this is a historical baseline, not a live benchmark. Pair it with current sources.

A practical next step: open the app in a browser with JavaScript enabled, note the survey population and date before quoting any figure, and compare its 2023 patterns against what your own stack uses today. For a broader view of the same ecosystem, the official Streamlit site at Streamlit documents the framework the app is built on.

How can I use the State of LLM Apps 2023 report to benchmark my own LLM application?

The report is best treated as a pattern benchmark, not a scoreboard. It surveys how real LLM apps in 2023 were built and operated, so you can compare your own choices—model provider, retrieval stack, evaluation approach, cost controls—against what was common at that point, and then decide where you are deliberately conventional and where you are deliberately different. Because the page is a JavaScript app with no rendered text in the source, expect to explore it interactively rather than read a static document.

A practical benchmarking routine

1. Fix your baseline first. Write down your current stack in one page: model(s), prompting strategy, retrieval or tools, hosting, evaluation method, and rough cost per request. Without this, comparison becomes impressionistic.
2. Bucket yourself by app type. A customer-support assistant, an internal knowledge search tool and a code-generation product face different constraints. Compare only against apps in a similar bucket; cross-bucket comparisons mostly measure product category, not engineering quality.
3. Compare on decisions, not tools. For each area—model choice, retrieval, evaluation, guardrails, cost management—note whether you match the common pattern. A match is not automatically good; it means you inherit the same trade-offs everyone else accepted.
4. Turn gaps into hypotheses. If most apps evaluate with human review and you rely only on spot checks, that is a testable gap. If you use a heavier retrieval stack than comparable apps, ask whether your quality gain justifies the latency and maintenance.
5. Re-check periodically. A 2023 snapshot describes an early, fast-moving period. Use it as a historical reference point and pair it with your own current measurements for decisions today.

What to record

The most useful output is a short list of two or three concrete experiments—say, adding a fixed evaluation set or testing a cheaper model on a sample of traffic—each with a success metric you define yourself.

A useful next step: open State of LLM Apps 2023 and note the categories it segments apps by, then map your product into the closest one before drawing any conclusions.

What trends in LLM app adoption does the 2023 report reveal?

The available page information does not include the report's findings, so I can't state which adoption trends the 2023 edition actually reports. The only content present is a notice that the app requires JavaScript, which tells you nothing about its data.

What to do instead

Open State of LLM Apps 2023 in a browser with JavaScript enabled and look for sections on:

• Which model providers teams chose and how that mix shifted during the year
• Build patterns — whether apps leaned on hosted APIs, retrieval over private data, or agents and tool use
• Who was building — company size, team type, and whether projects were internal tools or customer-facing
• Where projects stalled — evaluation, cost control, latency, or data privacy

As a reader, treat each chart as a snapshot of the surveyed population rather than the whole market; check the sample and collection method before generalizing. If you need a second view, the annual AI index from Stanford AI Index and vendor developer surveys cover adjacent ground with different samples.

Which LLM models and providers were most commonly used in production apps in 2023?

The supplied page information for State of LLM Apps 2023 does not include the survey's model or provider breakdown — the page evidence only shows the JavaScript-loading notice — so I can't name the specific leaders from this source. Treat any ranking you see elsewhere as something to verify against the survey itself before citing it.

How to get a usable answer

• Open the app in a browser with JavaScript enabled and look for the model/provider chart (often labelled by vendor, e.g. OpenAI, Anthropic, open-source options).
• Note whether the chart counts apps, respondents or API calls — these give very different pictures.
• Check the survey's sample: a developer-tool audience skews toward whichever provider dominates prototyping, not necessarily production volume.

A concrete way to use such data

If you're choosing a default provider for a new product, compare the survey's production-app shares against your own constraints: data-residency requirements, latency budget, and whether you need a fallback model. A common practical pattern is a primary hosted model for quality-sensitive tasks plus a cheaper or self-hosted model for high-volume, low-complexity calls — but confirm the survey's actual figures before using them to justify that split.

For broader market context, official vendor sites such as OpenAI and Anthropic publish their own usage and availability information, though neither substitutes for independent survey data.

What common challenges or failure modes do LLM app builders report in this data?

The supplied page evidence is limited to a JavaScript-required notice, so it does not list specific challenges or failure modes. What follows is practical guidance for what to look for in such survey data, not claims about this dataset's findings.

What to check in the data

LLM app builders most often report problems in a few recurring areas. When reading the survey, look for these categories:

• Evaluation and quality control: difficulty measuring output quality, building reliable test sets, and catching regressions.
• Hallucination and grounding: models producing confident but wrong answers, especially without retrieval.
• Cost and latency: token costs and response times making some use cases impractical.
• Prompt fragility: prompts that work in testing but break with small input changes.
• Data and retrieval quality: poor chunking, stale documents, or weak search leading to bad answers.
• Safety and abuse: prompt injection, jailbreaks, and filtering harmful output.
• Production operations: monitoring, logging, and handling model or API changes.

How to use it

Treat each reported challenge as a design checkpoint. For an internal support assistant, for example, prioritize retrieval quality and evaluation before scaling; for a customer-facing tool, prioritize safety filters and latency budgets. If the page requires JavaScript, open it in a browser with scripting enabled to read the actual responses rather than relying on secondhand summaries.

How does the report distinguish between experimental and production LLM use cases?

The report does not appear to separate experimental and production use cases into two clean categories. Based on the available page evidence, the site is an interactive Streamlit application titled "State of LLM Apps 2023," and its content renders only with JavaScript enabled, so the specific distinction it draws cannot be confirmed from the page text alone.

What a practical reader should expect

Survey-style reports on LLM adoption typically separate use cases along a maturity spectrum rather than a binary split. A reader trying to map the report's framing onto their own work should look for signals such as:

• Deployment status — whether a use case is a prototype, internal pilot, or live customer-facing tool.
• Team and ownership — hobbyist or skunkworks experiments versus dedicated product teams.
• Evaluation and guardrails — presence of testing, monitoring, or human review.
• Spend and infrastructure — free-tier tinkering versus committed API or hosting budgets.

Next step

Open the app with JavaScript enabled and check whether it filters or segments results by deployment stage. If it does, use that split to benchmark your own project: an internal pilot with light evaluation is closer to the experimental end, while a customer-facing tool with monitoring belongs in the production group. Treat any labels as the report's own framing, not a universal standard.