Skip to content
J·BJon BishopFractional growth marketer

Data platforms · llms.txt file breakdown

Streamlit llms.txt

A directly retrieved Markdown index for Streamlit's documentation, with 375 links across 20 detected headings.

The actual file

Source Markdown

The saved llms.txt text, displayed as source. The file belongs to its publisher; the live endpoint may change.

Open saved text ↗

Showing the first 18000 characters. Load the complete file to read the remainder.

# Streamlit documentation website

> Streamlit is a powerful open-source Python framework that allows data
scientists and AI/ML engineers to build interactive apps (i.e. data apps)
with only a few lines of code.

## [Get started](/get-started)

Get started with Streamlit, from installation to your first app.

### [Installation](/get-started/installation)

Learn how to install Streamlit with comprehensive guides to use pip, conda, Anaconda Distribution, cloud environments, and command line tools.

- [Use Streamlit Playground](/get-started/installation/streamlit-playground)
  Quick start guide to Streamlit using the Streamlit Playground - no installation required.
- [Install via command line](/get-started/installation/command-line)
  Step-by-step guide to install Streamlit using command line tools and build your first Hello World app.
- [Install via Anaconda Distribution](/get-started/installation/anaconda-distribution)
  Step-by-step guide to install Streamlit using Anaconda Distribution and build your first Hello World app.
- [Use GitHub Codespaces](/get-started/installation/community-cloud)
  Quick start guide to use Community Cloud and GitHub Codespaces for browser-based development without local installation.
- [Use Snowflake](/get-started/installation/streamlit-in-snowflake)
  Quick start guide to use Streamlit in Snowflake for secure development with role-based access control.

### [Fundamentals](/get-started/fundamentals)

Learn Streamlit fundamentals with guides on main concepts and features.

- [Basic concepts](/get-started/fundamentals/main-concepts)
  Learn the fundamental concepts of Streamlit including data flow, widgets, layout, and the development workflow for building interactive apps.
- [Advanced concepts](/get-started/fundamentals/advanced-concepts)
  Learn advanced Streamlit concepts including caching with st.cache_data and st.cache_resource, session state management, and database connections.
- [Additional features](/get-started/fundamentals/additional-features)
  Explore additional Streamlit features including theming, multipage apps, fragments, custom components, AI coding skills, and advanced UI customization options.
- [Summary](/get-started/fundamentals/summary)
  A summary of Streamlit's app model including execution flow, data handling, and state management.

### [First steps](/get-started/tutorials)

Build your first Streamlit apps with step-by-step tutorials for creating single-page and multi-page applications.

- [Create an app](/get-started/tutorials/create-an-app)
  Step-by-step tutorial for creating your first Streamlit app.
- [Create a multipage app](/get-started/tutorials/create-a-multipage-app)
  Build your first multipage app.

## [Develop](/develop)

Complete development resources for building beautiful, performant web apps with Streamlit including concepts, API reference, tutorials, and quick references.

### [Concepts](/develop/concepts)

Explore comprehensive guides to Streamlit development concepts including architecture, app design, testing, configuration, connections, custom components, and multipage applications.

- [Architecture and execution](/develop/concepts/architecture)
  Explore comprehensive guides about Streamlit's architecture and execution model, including app lifecycle, caching, session state, forms, fragments, and widget behavior.
  - [Running your app](/develop/concepts/architecture/run-your-app)
    Learn how to run Streamlit apps locally, set parameters, configure environment variables, and understand the execution model for development and production.
  - [Streamlit's architecture](/develop/concepts/architecture/architecture)
    Learn about Streamlit's client-server architecture, WebSocket connections, session management, and deployment considerations.
  - [The app chrome](/develop/concepts/architecture/app-chrome)
    Learn about Streamlit's app chrome including the status area, toolbar, and configurable app menu with developer options and deployment features.
  - [Caching](/develop/concepts/architecture/caching)
    Learn about Streamlit's caching mechanisms including st.cache_data and st.cache_resource for improving app performance and managing expensive computations.
  - [Session State](/develop/concepts/architecture/session-state)
    Learn about Session State for sharing variables between reruns, implementing callbacks, and building stateful applications across user sessions.
  - [Forms](/develop/concepts/architecture/forms)
    Learn how to use Streamlit forms with st.form to batch user input, control app reruns, and create efficient interactive interfaces with submit buttons.
  - [Fragments](/develop/concepts/architecture/fragments)
    Learn how to use Streamlit fragments to optimize app performance by rerunning portions of code instead of full scripts, improving efficiency for complex applications.
- [Architecture and execution/ Widget behavior](/develop/concepts/architecture/widget-behavior)
  Learn how Streamlit widgets behave across reruns, handle state persistence, manage user interactions, and control widget lifecycle in your applications.
- [Multipage apps](/develop/concepts/multipage-apps)
  Explore comprehensive guides about creating multipage Streamlit apps with navigation, page management, URL routing, and best practices for organizing complex apps.
  - [Overview](/develop/concepts/multipage-apps/overview)
    Learn about Streamlit's features for creating multipage apps using st.navigation, st.Page, and the pages directory with automatic navigation.
  - [Page and navigation](/develop/concepts/multipage-apps/page-and-navigation)
    Learn how to use the most flexible and preferred method for defining multipage apps.
  - [Pages directory](/develop/concepts/multipage-apps/pages-directory)
    Learn how to create multipage Streamlit apps using the simple pages/ directory approach with automatic page recognition and sidebar navigation.
  - [Working with widgets](/develop/concepts/multipage-apps/widgets)
    Learn how widgets behave across pages in multipage Streamlit apps, including widget state management, IDs, and cross-page interactions.
- [App design](/develop/concepts/design)
  Explore comprehensive guides about app design including layouts and containers, updating elements, button behavior, custom styling, dataframe design, multithreading, and timezone handling.
  - [Using layouts and containers](/develop/concepts/design/layouts-and-containers)
    Learn how to arrange and organize elements in your Streamlit app using containers, columns, tabs, expanders, flex layouts, and dynamic containers.
  - [Update and replace elements](/develop/concepts/design/animate)
    Learn how Streamlit commands return objects you can use to update, replace, or clear elements in place. Understand the difference between element objects, container objects, widget values, and widget-mode elements.
  - [Button behavior and examples](/develop/concepts/design/buttons)
    Learn about Streamlit button behavior, state management, and practical examples using st.button with st.session_state for interactive applications.
  - [Dataframes](/develop/concepts/design/dataframes)
    Learn how to display and edit tabular data in Streamlit using st.dataframe and st.data_editor, including styling, configuration, and interactive features.
  - [Multithreading](/develop/concepts/design/multithreading)
    Learn about multithreading in Streamlit applications, including limitations, best practices, and techniques for implementing concurrent processes safely.
  - [Using custom classes](/develop/concepts/design/custom-classes)
    Learn best practices for using custom Python classes, dataclasses, and Enums in Streamlit apps, including handling class redefinition and comparison issues across reruns.
  - [Working with timezones](/develop/concepts/design/timezone-handling)
    Learn how Streamlit handles timezones, including best practices for displaying datetime information across different user timezones.
- [Connections, secrets, and authentication](/develop/concepts/connections)
  Explore comprehensive guides to connecting Streamlit apps to data sources, managing secrets securely, implementing user authentication, and following security best practices.
  - [Connecting to data](/develop/concepts/connections/connecting-to-data)
    Learn how to connect Streamlit apps to databases, APIs, and data sources with best practices for data retrieval, caching, and secure data connections.
  - [Secrets management](/develop/concepts/connections/secrets-management)
    Learn how to manage API keys, credentials, and sensitive data in Streamlit apps using native secrets management and environment variables.
  - [User authentication](/develop/concepts/connections/authentication)
    Learn how to implement user authentication and personalization in Streamlit apps with admin controls, user information, and personalized experiences across sessions.
  - [Security reminders](/develop/concepts/connections/security-reminders)
    Learn about essential security practices for Streamlit apps including protecting secrets, secure coding practices, and preventing security vulnerabilities.
- [Custom components](/develop/concepts/custom-components)
  Learn about Streamlit custom components - powerful extensions that unlock capabilities beyond built-in widgets using web technologies.
  - [Overview](/develop/concepts/custom-components/overview)
    Understand what Streamlit custom components are, when to use them, and compare the v1 and v2 approaches for building interactive extensions.
  - [Components v2](/develop/concepts/custom-components/components-v2)
    Learn about Streamlit custom components v2 - the next generation framework with enhanced capabilities, bidirectional communication, and simplified development.
    - [Quickstart examples](/develop/concepts/custom-components/components-v2/examples)
      Get started quickly with Custom Components v2 through practical examples showing interactive buttons, data exchange, and complete component implementations.
      - [Hello world](/develop/concepts/custom-components/components-v2/examples/hello-world)
        A simple static component that displays themed text using Streamlit's CSS custom properties.
      - [Rich data](/develop/concepts/custom-components/components-v2/examples/rich-data)
        A component that receives different data types from Python including DataFrames, JSON, and base64 images.
      - [Simple button](/develop/concepts/custom-components/components-v2/examples/simple-button)
        An interactive button component that sends trigger values to Python when clicked.
      - [Simple checkbox](/develop/concepts/custom-components/components-v2/examples/simple-checkbox)
        A simple checkbox component that sends persistent state values to Python.
      - [Interactive counter](/develop/concepts/custom-components/components-v2/examples/interactive-counter)
        A counter component demonstrating state values, trigger values, multiple event handlers, and cleanup functions.
      - [Text input](/develop/concepts/custom-components/components-v2/examples/text-input)
        A text input component demonstrating bidirectional communication with programmatic updates from Python.
      - [Danger button](/develop/concepts/custom-components/components-v2/examples/danger-button)
        A hold-to-confirm button with frontend validation, visual feedback, and rate limiting.
      - [Radial menu](/develop/concepts/custom-components/components-v2/examples/radial-menu)
        A radial selection menu demonstrating state values for persistent selections.
    - [Registration](/develop/concepts/custom-components/components-v2/register)
      Learn how to register custom v2 components with HTML, CSS, and JavaScript to define their structure and behavior.
    - [Mounting](/develop/concepts/custom-components/components-v2/mount)
      Learn how to mount custom v2 components in your Streamlit app, pass data, handle callbacks, and access component values.
    - [State vs trigger values](/develop/concepts/custom-components/components-v2/state-and-triggers)
      Learn the fundamental difference between state and trigger values in Custom Components v2, and when to use each approach for bidirectional communication.
    - [Bidirectional communication](/develop/concepts/custom-components/components-v2/communicate)
      Learn how to exchange data between your custom v2 component and Python, including sending data to the frontend and receiving user interactions.
    - [Theming and styling](/develop/concepts/custom-components/components-v2/theming)
      Learn how to style Custom Components v2 with Streamlit's theme integration, CSS custom properties, and responsive design patterns.
    - [Package-based components](/develop/concepts/custom-components/components-v2/package-based)
      Learn how to build complex Custom Components v2 using package-based development with TypeScript, modern build tools, and external dependencies.
  - [Components v1](/develop/concepts/custom-components/components-v1)
    Learn how to build and use custom Streamlit components to extend app functionality with third-party Python modules and custom UI elements.
    - [Intro to v1 components](/develop/concepts/custom-components/components-v1/intro)
      Learn to develop Streamlit custom components with static and bi-directional communication between Python and JavaScript for extended functionality.
    - [Create a component](/develop/concepts/custom-components/components-v1/create)
      Step-by-step guide to creating custom Streamlit components from scratch, including setup, development environment, and component structure.
    - [Limitations](/develop/concepts/custom-components/components-v1/limitations)
      Understand the limitations and constraints of Streamlit custom components including iframe restrictions and differences from base Streamlit functionality.
  - [Publish a component](/develop/concepts/custom-components/publish)
    Learn how to publish Streamlit custom components to PyPI, making them accessible to the Python community and Streamlit users worldwide.
  - [Component gallery](https://streamlit.io/components)
- [Configuration and theming](/develop/concepts/configuration)
  Explore comprehensive guides about configuring and customizing Streamlit apps including theming, HTTPS setup, static file serving, and custom styling.
  - [Configuration options](/develop/concepts/configuration/options)
    Learn about configuration options including config.toml files, environment variables, command-line flags, and runtime configuration management.
  - [HTTPS support](/develop/concepts/configuration/https-support)
    Configure HTTPS/SSL for Streamlit apps with TLS protocol, SSL termination, reverse proxies, and security best practices for production deployment.
  - [Serving static files](/develop/concepts/configuration/serving-static-files)
    Learn about static file serving in Streamlit to host and serve media files, assets, and resources that support media embedding and custom content.
  - [Customize your theme](/develop/concepts/configuration/theming)
    Learn about theming options in config.toml, including color schemes, fonts, and visual styling.
  - [Customize colors and borders](/develop/concepts/configuration/theming-customize-colors-and-borders)
    Learn how to customize colors, borders, backgrounds, and UI elements in Streamlit apps using theme configuration options and color values.
  - [Customize fonts](/develop/concepts/configuration/theming-customize-fonts)
    Learn how to configure fonts in Streamlit apps by loading custom font files from URLs or static file serving, with configuration options for different text elements.
- [App testing](/develop/concepts/app-testing)
  Explore comprehensive guides about Streamlit's native app testing framework, including setup, examples, and best practices for CI/CD integration.
  - [Get started](/develop/concepts/app-testing/get-started)
    Learn the fundamentals of Streamlit app testing with practical examples covering test structure, AppTest initialization, element retrieval, widget manipulation, and result inspection.
  - [Beyond the basics](/develop/concepts/app-testing/beyond-the-basics)
    Learn Streamlit app testing techniques covering AppTest mutable attributes including secrets, session state, query parameters, and advanced testing patterns.
  - [Automate your tests](/develop/concepts/app-testing/automate-tests)
    Learn how to integrate Streamlit app testing with Continuous Integration systems like GitHub Actions for automated testing workflows.
  - [Example](/develop/concepts/app-testing/examples)
    Complete example of testing a Streamlit login page including authentication logic, secrets management, security best practices, and comprehensive test coverage.
  - [Cheat sheet](/develop/concepts/app-testing/cheat-sheet)
    Quick reference guide for Streamlit app testing with AppTest, covering common testing patterns for text elements, widgets, charts, and interactive components.

### [API reference](/develop/api-reference)

Visually explore a gallery of Streamlit's API.

- [Write and magic](/develop/api-reference/write-magic)
  Display information in Streamlit apps using st.write and magic commands - versatile tools for showing text, data, charts, and more with minimal code.
  - [st.write](/develop/api-reference/write-magic/st.write)
    st.write displays its argument in your app.
  - [st.write_stream](/develop/api-reference/write-magic/st.write_stream)
    st.write_stream displays a stream or generator in your app using a typewriter effect.
  - [magic](/develop/api-reference/write-magic/magic)
    Magic commands in Streamlit allow you to display content without explicit commands - just put Markdown strings, data, or charts on their own line.
- [Text elements](/develop/api-reference/text)
  Display and format text in Streamlit apps with titles, headers, markdow

Measured from the saved file

Linked document

UTF-8 text size
65.9 KB67454 bytes
Token count
13821o200k_base encoding
Markdown links
375366 distinct URLs
Fenced code blocks
0790 lines in the file

Size measures the captured UTF-8 text, not compressed transfer size. Tokens are counted with a named tokenizer; other models can count differently. Neither measure establishes context compatibility or answer quality.

Project H1
Streamlit documentation website

Opening blockquote

Streamlit is a powerful open-source Python framework that allows data

Context architecture

How the content is divided

4 H2 sections organize 375 parsed Markdown links. 1 links point to .md or .markdown paths; 4 link occurrences use another hostname. Linked destinations have not been recursively validated.

H2 sectionLinksUTF-8 bytesTokens
[Get started](/get-started)Line 7152468529
[Develop](/develop)Line 483135518411333
[Deploy](/deploy)Line 6774390581810
[Knowledge base](/knowledge-base)Line 776441974

Link counts exclude parsed fenced and inline code and resolve relative destinations against the final endpoint. Section sizes cover the text below each H2 until the next H2.

Embedded material

Code, installation and API examples

Fenced blocks
0 closed
Declared languages
No fenced blocks detected
Package-install commands
0 detected in fenced or inline code
Authentication examples
0 fenced lines match API-key, Authorization, Bearer, OAuth or access-token patterns
HTTP request examples
0 fenced lines match request-method patterns
Authentication links
0 links have authentication-related labels

Embedded example text and links to further documentation are counted separately. A code block does not establish that a sample runs or that an authentication flow succeeds.

Publisher prioritization

The Optional section

No H2 section named “Optional” was detected in this file.

The community proposal uses Optional by convention for secondary links that can be skipped for a shorter context. This label does not establish that everything outside it is critical, or that the material inside it is deprecated.

Machine-readable routes

MCP references and configuration text

No MCP or Model Context Protocol term was detected in the captured file. 0 links have MCP-related labels or paths. 0 fenced lines match mcpServers, mcp_servers or an mcp add command.

These are text and link observations. No MCP server connection, authentication or tool call was tested.

Index and bundle

llms-full.txt companion

Verified text companion

Text companion verified

https://docs.streamlit.io/llms-full.txt ↗
Discovery
Conventional sibling path checked
HTTP response
206 · text/plain; charset=UTF-8
Text size
1.9 MB · 2035759 bytes (server-reported)
Token count
488859 o200k_base tokens
Retrieval scope
Complete body retrieved

A verified text response establishes a companion at the checked URL. It does not prove the bundle contains all product documentation, that generation is automated, or that it fits an assistant’s context window.

Change evidence

What can be said about freshness

This capture establishes a baseline. Update frequency cannot be determined from one observation.

Linked release and migration material

10 links have release, changelog, deprecation or migration terms in their labels or paths. These provide places to investigate product changes separately.

File changes can reveal documentation edits or navigation changes. They do not by themselves measure product release velocity, accuracy, agent adoption or AI visibility.

Capture identity and measurement method
Requested endpoint
https://docs.streamlit.io/llms.txt
Final endpoint
https://docs.streamlit.io/llms.txt
HTTP status
200
Content type
text/plain; charset=UTF-8
Text retrieval
Firecrawl literal text capture
Tokenizer
tiktoken 0.14.0 · o200k_base
SHA-256 of saved UTF-8 text
e1f981bef0b1620739fc829078ef6b75d57abbb43a54ed3d850e92ce4655ae2e

Counts use a deterministic parser, not a spec-compliance grade. Unusual Markdown and indented code can fall outside its recognized patterns. See the llms.txt proposal and tokenizer implementation.

Related tools and resources

Contact Jon