A few months ago, Simon Willison posted a compelling definition of agents on his blog: “An LLM agent runs tools in a loop to achieve a goal.” This got me thinking about how ellmer and chatlas, two R and Python packages for building LLM chat applications, handle the tool loop.

The answer? They handle it automatically. Once you register your tools with a Chat object, the R package and Python library take care of the entire loop for you. There’s no additional steps required.

Seeing the Tool Loop in Action

Here’s a minimal example showing how ellmer automatically manages multiple tool calls to solve a math problem:

``` r
library(ellmer)

# Define simple R functions
adder <- function(a,b){
  return(a + b)
}

multer <- function(a,b){
  return(a * b)
}

# Wrap them as tools with descriptions
tool_adder <- tool(
  adder,
  description = "Adds two numbers together.",
  arguments  = list(
    a = type_integer("First number to add."),
    b = type_integer("Second number to add.")
  )
)

tool_multer <- tool(
  multer,
  description = "Multiplies two numbers together.",
  arguments  = list(
    a = type_integer("First number to multiply."),
    b = type_integer("Second number to multiply.")
  )
)

# Create a chat and register the tools
chat <- chat_anthropic(model = "claude-3-7-sonnet-20250219")

chat$register_tool(tool_adder)
chat$register_tool(tool_multer)

# Ask the LLM to solve a problem requiring multiple tool calls
response <- chat$chat("Can you use adder and multer to solve 50101*1020+547892+10010? Just give me the numeric answer with no commas.")
#> I'll solve 50101*1020+547892+10010 using the available tools.
#> 
#> First, I'll multiply 50101 by 1020, and then add the result to 547892 and 
#> 10010.
#> ◯ [tool call] multer(a = 50101L, b = 1020L)
#> ● #> 51103020
#> Now I'll add the multiplication result (51103020) to 547892:
#> ◯ [tool call] adder(a = 51103020L, b = 547892L)
#> ● #> 51650912
#> Finally, I'll add 10010 to the previous result:
#> ◯ [tool call] adder(a = 51650912L, b = 10010L)
#> ● #> 51660922
#> The answer is 51660922.

# Verify the result
expectation <- 50101*1020+547892+10010

grepl(
  pattern = as.character(expectation), 
  x = expectation
)
#> [1] TRUE
```

<sup>Created on 2025-11-06 with [reprex v2.0.2](https://reprex.tidyverse.org)</sup>

Notice how the Chat object seamlessly handled three sequential tool calls without any manual intervention. The LLM decided which tools to call, in what order, and when it had enough information to provide the final answer.

Here’s an example using Chatlas in Python too (you can run this one yourself to see each of the tool calls):

import chatlas as ctl
from dotenv import load_dotenv
load_dotenv()

# Define simple Python functions
def adder(a: int, b: int) -> int:
    """
    Adds two numbers together.
    
    Parameters
    ----------
    a : int
        First number to add.
    b : int
        Second number to add.
    """
    return a + b

def multer(a: int, b: int) -> int:
    """
    Multiplies two numbers together.
    
    Parameters
    ----------
    a : int
        First number to multiply.
    b : int
        Second number to multiply.
    """
    return a * b

# Create a chat and register the tools
chat = ctl.ChatAnthropic(model="claude-3-7-sonnet-20250219")
chat.register_tool(adder)
chat.register_tool(multer)

# Ask the LLM to solve a problem requiring multiple tool calls
response = chat.chat("Can you use adder and multer to solve 50101*1020+547892+10010? Just give me the numeric answer with no commas.")

# Verify the response contains the expected answer
expectation = 50101 * 1020 + 547892 + 10010
assert str(expectation) in response.content

What’s Happening Behind the Scenes

The Chat object is doing the heavy lifting here:

1. Managing conversation state: It tracks all messages exchanged between you and the LLM
2. Executing the tool loop: When the LLM requests a tool call, the Chat object executes your R/Python function, captures the result, and sends it back to the LLM
3. Iterating until completion: This loop continues until the LLM has everything it needs to answer your question

This abstraction means you can focus on defining your tools and asking questions, while the package and library handles all the orchestration.

Learn More

Both packages offer similar functionality:

The Chat object - Chat

“A Chat is a sequence of user and assistant Turns sent to a specific Provider. A Chat is a mutable R6 object that takes care of managing the state associated with the chat; i.e. it records the messages that you send to the server, and the messages that you receive back. If you register a tool (i.e. an R function that the assistant can call on your behalf), it also takes care of the tool loop.

You should generally not create this object yourself, but instead call chat_openai() or friends instead.”

chatlas

“A chat object that can be used to interact with a language model.

A Chat is an sequence of sequence of user and assistant Turns sent to a specific Provider. A Chat takes care of managing the state associated with the chat; i.e. it records the messages that you send to the server, and the messages that you receive back. If you register a tool (i.e. an function that the assistant can call on your behalf), it also takes care of the tool loop.”

By automatically handling the tool loop, these packages make it remarkably simple to build LLM agents that can accomplish multi-step tasks using the functions you provide.

Building AI-powered applications with Shiny has become increasingly accessible thanks to open-source packages like shinychat and ellmer. However, as LLM costs can quickly add up, monitoring token usage and expenses in real-time is crucial for production applications

The Challenge

When I was working on diagrambot (a fork of Posit’s ggbot2), I realized the importance of cost transparency. Users should know how much their AI interactions are costing, and developers need to monitor usage patterns to optimize their applications. ggbot2 does this and diagrambot does it too on top of the Shinyrealtime R package.

The Solution: Built-in Tracking with ellmer

The good news? The ellmer package makes this surprisingly straightforward, if you’re developing chat-based LLM apps. It provides built-in methods to track both token usage and approximate costs across all major LLM providers, calculating these metrics automatically as your chat progresses.

Key Methods

• get_tokens(): Returns a data frame with detailed token usage per interaction
• get_cost(): Calculates cumulative costs based on the provider's pricing model

Implementation: Before and After

Let’s transform a basic Shinychat app (Shinychat app in the ellmer docs) to include real-time cost and token tracking. Here’s how this would look if you wanted to do this.

Before: Basic Chat App

library(shiny)
library(shinychat)

ui <- bslib::page_fillable(
  chat_mod_ui("chat")
)

server <- function(input, output, session) {
  chat <- ellmer::chat_openai(
    system_prompt = "You're a trickster who answers in riddles",
    model = "gpt-4.1-nano"
  )

  chat_mod_server("chat", chat)
}

shinyApp(ui, server)

After: Enhanced with Cost Tracking

library(shiny)
library(shinychat)

ui <- bslib::page_fillable(
  # Token and cost tracking display
  div(
    style = "padding: 10px; margin-bottom: 10px; background-color: #f8f9fa; border-radius: 5px;",
    helpText(
      "Cost: ",
      textOutput("session_cost_chat", inline = TRUE),
      " | Tokens: ",
      textOutput("session_tokens_chat", inline = TRUE)
    )
  ),
  chat_mod_ui("chat")
)

server <- function(input, output, session) {
  chat <- ellmer::chat_openai(
    system_prompt = "You're a trickster who answers in riddles",
    model = "gpt-4.1-nano"
  )

  chat_mod_server("chat", chat)
  
  # Use reactiveValues for mutable state
  values <- reactiveValues(
    last_turn_count = 0,
    tokens = 0,
    cost = 0
  )
  
  # Only update when turns actually change
  observe({
    invalidateLater(1000)  # Check every second
    
    current_turns <- length(chat$get_turns())
    
    # Only recalculate if turns have actually changed
    if (current_turns != values$last_turn_count) {
      values$last_turn_count <- current_turns
      
      # Update metrics only when needed
      tokens_df <- chat$get_tokens()
      values$tokens <- if(nrow(tokens_df) > 0) sum(tokens_df$tokens, na.rm = TRUE) else 0
      values$cost <- chat$get_cost(include = "all")
    }
  })
  
  # Clean reactive outputs
  output$session_cost_chat <- renderText({
    sprintf("$%.4f", values$cost)
  })
  
  output$session_tokens_chat <- renderText({
    as.character(values$tokens)
  })
}

shinyApp(ui, server)

Key Implementation Details

1. Efficient State Management

Using reactiveValues() provides a clean way to manage mutable state across the application, avoiding unnecessary re-computations.

2. Update Logic

The code only recalculates costs and tokens when the conversation actually changes (detected by monitoring turn count).

Production Considerations

When deploying this pattern in production applications, you might use it to consider:

• Rate Limiting: Add logic to prevent excessive usage
• User Budgets: Implement per-user cost limits
• Historical Tracking: Store usage data for analytics
• Multiple Models: Track costs across different LLM providers

Conclusion

Adding cost and token tracking to your Shinychat applications is both straightforward and essential. The ellmer package’s built-in methods make it easy to provide transparency to users while giving developers the insights they need to optimize their AI-powered applications. If you’re using Python, the chatlas Chat object, also from Posit, has similar token usage and cost tracking methods you should check out. Note that ellmer seems to retrieve pricing info from the LiteLLM GitHub repo and have emphasized treating token costs provided from the package as approximations before. The same probably also applies to chatlas.

This pattern has proven useful in diagrambot and can easily be adapted to any Shinychat-based application. Your users will appreciate the transparency, and you’ll have the data needed to make informed decisions about model selection and usage optimization.

I've recently been using ellmer a lot for different fun projects on my Github. I love the R6 Chat object that the package uses to send messages to an LLM provider. I recently realized that there is a method in the object to set the turns to whatever you want. This reminded me of an Anthropic training, where they show you how you can pass your own series of messages (as long as they comply with the convention) through to the model.

This technique essentially lets you craft the conversation history that Claude sees, giving you precise control over how the assistant responds. Each Turn represents one exchange in the conversation, with a role (user or assistant) and the content of that exchange. By setting up these turns manually, you can establish patterns, demonstrate specific response styles, or create few-shot learning examples.

The applications for this are quite powerful. You could get a conversation from one model and seamlessly continue it with another model. You might establish a consistent persona or response format across multiple interactions. Or you can create training examples that teach Claude to respond in a very specific way to certain types of input.

Let me show you how this works with a simple sentiment analysis reprex where we "teach" Claude to classify pickle-related tweets as either POSITIVE or NEGATIVE. This example is straight from the Anthropic training.

``` r
library(ellmer)
#> Warning: package 'ellmer' was built under R version 4.3.3

chat <- chat_anthropic()
#> Using model = "claude-sonnet-4-20250514".

turns <- list(
  Turn(role = "user", contents = list(ContentText("Unpopular opinion: Pickles are disgusting. Don't @ me"))),
  Turn(role = "assistant", contents = list(ContentText("NEGATIVE"))),
  Turn(role = "user", contents = list(ContentText("I think my love for pickles might be getting out of hand. I just bought a pickle-shaped pool float"))),
  Turn(role = "assistant", contents = list(ContentText("POSITIVE"))),
  Turn(role = "user", contents = list(ContentText("Seriously why would anyone ever eat a pickle?  Those things are nasty!"))),
  Turn(role = "assistant", contents = list(ContentText("NEGATIVE")))
)

chat$set_turns(turns)

chat$chat("Just tried the new spicy pickles from @PickleCo, and my taste buds are doing a happy dance! 🌶️🥒 #pickleslove #spicyfood")
#> POSITIVE

chat
#> <Chat Anthropic/claude-sonnet-4-20250514 turns=8 tokens=134/5 $0.00>
#> ── user [0] ────────────────────────────────────────────────────────────────────
#> Unpopular opinion: Pickles are disgusting. Don't @ me
#> ── assistant [0] ───────────────────────────────────────────────────────────────
#> NEGATIVE
#> ── user [0] ────────────────────────────────────────────────────────────────────
#> I think my love for pickles might be getting out of hand. I just bought a pickle-shaped pool float
#> ── assistant [0] ───────────────────────────────────────────────────────────────
#> POSITIVE
#> ── user [0] ────────────────────────────────────────────────────────────────────
#> Seriously why would anyone ever eat a pickle?  Those things are nasty!
#> ── assistant [0] ───────────────────────────────────────────────────────────────
#> NEGATIVE
#> ── user [134] ──────────────────────────────────────────────────────────────────
#> Just tried the new spicy pickles from @PickleCo, and my taste buds are doing a happy dance! 🌶️🥒 #pickleslove #spicyfood
#> ── assistant [5] ───────────────────────────────────────────────────────────────
#> POSITIVE
```

<sup>Created on 2025-06-28 with [reprex v2.0.2](https://reprex.tidyverse.org)</sup>

As you can see, by providing Claude with a few examples of how to classify pickle-related sentiment, it learned the pattern and correctly identified the enthusiastic tweet about spicy pickles as POSITIVE. This approach gives you another level of control over how the assistant responds to you, making it particularly useful for tasks requiring consistent formatting or specific response patterns. By crafting synthetic assistant responses in your conversation history, you can effectively demonstrate exactly how you want the model to behave without needing actual prior interactions. This technique opens up interesting possibilities for creating more sophisticated interactions with language models, whether you’re building specialized tools or just experimenting with different ways to guide AI responses.

Posit Conf 2024 in Seattle was great! Just like my post from last year, here’s a list of packages, tools, and resources I learned more about at the conference.

Packages

• cards — https://insightsengineering.github.io/cards/latest-tag/, https://github.com/insightsengineering/cards
• xportr — https://atorus-research.github.io/xportr/index.html
• admiral — https://pharmaverse.github.io/admiral/
• gtsummary — http://www.danieldsjoberg.com/gtsummary
• tfrmt — https://gsk-biostatistics.github.io/tfrmt/
• labelled — https://larmarange.github.io/labelled/
• matte — https://atorus-research.github.io/matte/
• crew — https://wlandau.github.io/crew/

Quarto extensions

• closeread — https://closeread.netlify.app/ , https://github.com/qmd-lab/closeread
• quarto-live — https://r-wasm.github.io/quarto-live/, https://github.com/r-wasm/quarto-live

AI tools

• Recraft — https://www.recraft.ai
• Scribe — https://scribehow.com
• Descript — https://www.descript.com/
• Embedding.io — https://www.embedding.io/

Books

• Not the End of the World: How We Can Be the First Generation to Build a Sustainable Planet — https://www.amazon.com/dp/031653675X/?coliid=I2GCGMSTBM8O2M&colid=SN2SYH9862VT&psc=1&ref_=list_c_wl_lv_ov_lig_dp_it
• Factfulness: Ten Reasons We’re Wrong About the World — and Why Things Are Better Than You Think — https://www.amazon.com/dp/1250107814/?coliid=I3OLO6YV0VIEU1&colid=SN2SYH9862VT&psc=1&ref_=list_c_wl_lv_ov_lig_dp_it

When working with data in R, it's often helpful to include metadata such as the full name of columns, data types, and lengths. This metadata can be stored in label attributes within R dataframes, which is particularly useful when dealing with large or complex datasets with many columns.

Checking for Label Attributes in Dataframes

In R, not all dataframes come with label attributes by default. However, if these attributes are present, they provide valuable context about your data. You can check if your dataframe includes label attributes by using the str() function. This function will display the structure of your dataframe, including any label attributes.

Alternatively, if you’re using the RStudio IDE, you can use the View() function to visually inspect your dataframe. When you hover over the column names, any associated label attributes will be displayed as a tooltip.

Using the labelled Package for Managing Column Labels

If your dataframe doesn’t have label attributes, or if you want to manage or add labels, the labelled package is a great tool. This package is particularly useful for working with data imported from SAS, SPSS or Stata, where label attributes are more common.

Manipulating Labelled Data

Installing and Loading the labelled Package

First, install and load the labelled package:

install.packages("labelled")
library(labelled)

Example: Generating a Data Dictionary

Let’s say you have imported a dataset from a XPT file using the haven package, which preserves the label attributes. You’ve confirmed that this has useful column labels we could use to create a data dictionary.

library(haven)
library(labelled)

# Importing a sas7bdat file
url <- "https://github.com/phuse-org/phuse-scripts/raw/master/data/adam/cdisc/adae.xpt"
df <- read_xpt(url)

# Check the structure to see the label attributes
str(df)

# Create a data dictionary using those attributes
generate_dictionary(df)

Conclusion

Utilizing label attributes in R can significantly enhance the usability of your dataframes, especially when dealing with large or complex datasets. By leveraging the labelled package's generate_dictionary() function, you can easily create comprehensive data dictionaries that make your data more understandable and accessible. You can also use the package to add labels into existing dataframes using var_label().

Whether you’re working with data imported from SPSS, Stata, or SAS files, incorporating label attributes into your workflow can save time and reduce errors, making your analysis more efficient.

Learn More

Shannon Pileggi had a great talk from this year’s Posit Conf on this topic. It should be posted on the Posit Youtube Channel later this year. You can check out her very thorough blog post on this topic to learn more:

PIPING HOT DATA: Leveraging labelled data in R

Lately, I’ve been diving deep into the world of Quarto Extensions in my free time. I’ve found myself creating functionalities that I wished I had for my presentation slides. Here’s a breakdown of the different Quarto extensions I’ve developed to support the RevealJS format. I’ve shared these on the official Quarto RevealJS plugins page too.

Speech Recognition Extension

This extension allows for real-time speech recognition during presentations, enhancing accessibility and interactivity. It lets you verbally control your slides. Check it out here: GitHub — parmsam/quarto-speech.

Subtitles Extension

Add live subtitles to your presentations with ease. This extension is perfect for making your content accessible to a broader audience. Explore it here: GitHub — parmsam/quarto-subtitles.

Text-to-Speech (TTS) Extension

This TTS extension reads out the content of your slides, providing an additional layer of accessibility and engagement for folks who may want to replay your slides. You can find it here: GitHub — parmsam/quarto-tts.

Live Webcam Video Feed Extension

Integrate a live webcam feed into your presentations to create a more dynamic and personal experience. Learn more about it here: GitHub — parmsam/quarto-webcam.

Flashcards Extension

A simple yet powerful tool to add flashcards to your presentations, perfect for quizzes and interactive learning sessions. Check it out here: GitHub — parmsam/quarto-flashcards.

Excalidraw Extension

Open an empty Excalidraw canvas within your presentations, allowing for real-time drawing and brainstorming. Explore this extension here: GitHub — parmsam/quarto-excalidraw.

Multiple Choice Quiz Extension

Add interactive multiple-choice quiz questions to your presentation slides, making them more engaging and educational. Learn more about it here: GitHub — parmsam/quarto-quiz.

Each of these extensions brings unique functionality to the RevealJS format, making presentations more interactive, accessible, and engaging. I hope you find them as useful as I have!

Posit Conf 2023 in Chicago was awesome! Here’s a list of packages and tools I learned about (or learned more about) at the conference. I’m making this list so it’s easier for me or others to explore documentation or source code. Tools followed by links. Here’s a link to the repo with my notes, for more info. Looking forward to next year’s conference in Seattle.

• {shinylive} for R— https://posit-dev.github.io/r-shinylive, /https://github.com/posit-dev/r-shinylive
• Shinylive Quarto extension (Python and R)— https://quarto-ext.github.io/shinylive/, https://github.com/quarto-ext/shinylive, https://github.com/posit-dev/r-shinylive
• Shinylive for R editor to run, write, and share Shiny for R apps directly in browser — https://shinylive.io/r/examples/
• {shinyuieditor} now out of alpha — https://rstudio.github.io/shinyuieditor/, https://github.com/rstudio/shinyuieditor
• Shiny for Python — https://shiny.posit.co/py/, https://github.com/posit-dev/py-shiny
• {bslib} >v0.5 — https://rstudio.github.io/bslib/index.html, https://github.com/rstudio/bslib
• webR — https://docs.r-wasm.org/webr/latest/, https://github.com/r-wasm/webr
• Chatstream — https://wch.github.io/chatstream/, https://github.com/wch/chatstream
• openplayground (for LLMs)— https://nat.dev/, https://github.com/nat/openplayground
• h2ogpt — https://gpt.h2o.ai/, https://github.com/h2oai/h2ogpt
• Codeowners files in Github — https://docs.github.com/en/repositories/managing-your-repositorys-settings-and-features/customizing-your-repository/about-code-owners
• Github Copilot with RStudio (in daily build for now) — https://dailies.rstudio.com/, https://colorado.posit.co/rsc/rstudio-copilot/#/TitleSlide
• R Packages book now in 2e — https://r-pkgs.org/
• {teal} — https://insightsengineering.github.io/teal/latest-tag/, https://github.com/insightsengineering/teal
• {tfrmt} — https://gsk-biostatistics.github.io/tfrmt/, https://github.com/GSK-Biostatistics/tfrmt
• {riskscore} — https://github.com/pharmaR/riskscore
• {riskmetric} —https://pharmar.github.io/riskmetric/, https://github.com/pharmaR/riskmetric
• {slushy} — https://gsk-biostatistics.github.io/slushy/, https://github.com/GSK-Biostatistics/slushy
• duckdb — https://duckdb.org/, https://github.com/duckdb/duckdb
• {duckplyr} — https://duckdblabs.github.io/duckplyr/, https://github.com/duckdblabs/duckplyr
• {dbtplyr} —https://emilyriederer.github.io/dbtplyr/, https://github.com/emilyriederer/dbtplyr
• siuba —https://siuba.org/, https://github.com/machow/siuba
• {vetiver} — https://vetiver.rstudio.com/, https://rstudio.github.io/vetiver-r/, https://github.com/rstudio/vetiver-r/
• {tidymodels} — https://tidymodels.tidymodels.org/, https://github.com/tidymodels/tidymodels, https://www.tidymodels.org/, https://www.tmwr.org/
• {targets} — https://docs.ropensci.org/targets/, https://github.com/ropensci/targets
• {epoxy} — https://pkg.garrickadenbuie.com/epoxy/, https://github.com/gadenbuie/epoxy, https://www.garrickadenbuie.com/talk/epoxy-super-glue/
• Quarto shortcode extensions — https://quarto.org/docs/extensions/listing-filters.html, https://github.com/rich-iannone/quarto-icons-examples, https://github.com/mcanouil/awesome-quarto
• Quartodoc — https://machow.github.io/quartodoc/get-started/overview.html, https://github.com/rich-iannone/quarto-icons-examples
• Parametrized Quarto — https://quarto.org/docs/computations/parameters.html#knitr, https://github.com/jadeynryan/2023_posit-parameterized-quarto/
• Formatting extension for Quarto called qformat — https://github.com/rich-iannone/qformat
• Quarto typst — https://quarto.org/docs/prerelease/1.4/typst.html, https://github.com/typst/typst

Here’s a quick update on what I’ve been up to with Shiny for Python. Last month, I cooked up a couple applications during my downtime, just for kicks.

Icebreaker-py

Meet Icebreaker-py, a source for randomized icebreaker questions. The dataset for this tool comprises around 100 unique questions that I curated with the assistance of ChatGPT. In addition to generating questions, I’ve integrated some user-friendly features:

• Randomize: Spice things up with the ‘R’ key to generate a new question. Use the slider to select up to five questions.
• Copy icebreakers: A quick press of the ‘C’ key copies the question to your clipboard.
• Toggle Difficulty: Dial the challenge up or down with the ‘D’ key.

Perhaps ChatGPT got a bit carried away with the emojis, but hey, who’s counting? 😅 Check it out for yourself here: Icebreaker-py on GitHub.

Pomotimer-py

Pomotimer-py presented a slightly steeper learning curve. Inspired by traditional Pomodoro timers, I recreated some apps I’ve found useful for enhancing my productivity. This project could give you valuable insights into the following:

• Navbar Layouts: How to structure an intuitive navigation interface.
• Modals: Pop-up elements to interact with the user.
• Shiny Reactivity: Real-time updates without having to refresh the page.

Curious? Take a look at the repository: Pomotimer-py on GitHub.

Both projects were fun to build and deepened my understanding of Shiny for Python. They’re live for you to use, remix, or draw inspiration from. Enjoy!

I started working on a short guidance book with tips and tricks for use of AI tools such as ChatGPT, Bard, Github Copilot or DALL-E. So far, it collects different use cases that I’ve run into as a programmer. Example prompts are also provided with a few of the use cases. This book is created using Quarto. It’s hosted on Github pages, with the source code available on Github.

It’s still a work in progress, but I thought I’d share it in a blog post.

• AI Assistants Maximized
• GitHub - parmsam/tips-and-tricks-ai-tools: AI Assistants Maximized: a book (WIP)

Alright, let’s keep it short. Shiny for Python is a Python library that lets you build cool apps in Python. Shinylive lets you Shiny for Python apps entirely in the web browser. What’s nice is that you can even pull live data from your Google Spreadsheets that you’ve made public into your Shinylive apps.

Here are two examples (see repo link below). One’s a birthday countdown app with a slider for upcoming birthdays and a search bar to quickly find someone’s day. The other’s an event countdown app, listing what’s coming up and allowing event name searches.

GitHub - parmsam/date-countdown-py: Example date countdown apps built using Shiny for Python

Want to learn more? Check out the link below to dive into Shiny for Python. Think of your own simple project that can use the library. This one took me about an hour or two after work. The documentation on the official website is great with tons of examples.

Shiny for Python