%>% dreams

Skills 101

Isabella Velásquez — Tue, 16 Jun 2026 00:00:00 GMT

Details

👥 2026 R/Pharma GenAI Day
📆 16 June 2026 // 11:20 AM ET
💻️ Virtual

Description

Throughout this conference, you’re going to hear the word “skill” a lot. These specifically mean “agent skills”, specialized tools and behaviors passed to large language models to make them actionable. If you’ve found yourself wondering, “What actually is a skill?”” then join us for Skills 101. We’ll break down what they are, what they are not, and how they work, giving you the foundational toolkit to navigate the rest of the conference.

Recording

Connecting Python with LLMs

Isabella Velásquez — Sat, 09 May 2026 00:00:00 GMT

Event Slides Repo

Details

👥 PyLadies Monterrey
📆 09 May 2026 // 12:30 PM CST
💻️ Virtual

Description

Large language models (LLMs) like ChatGPT and Claude have become powerful tools for everyday work, but using them through a browser interface is just the beginning. This talk explores how to connect Python code directly to LLMs using chatlas, a lightweight library that makes LLM integration straightforward and flexible.

Slides

Summary

Este resumen fue generado por Claude Sonnet 4.6 y revisado por mí.

¿Qué son los modelos de lenguaje grandes?

Los LLMs son modelos de IA entrenados con cantidades masivas de texto — libros, sitios web, código — que pueden entender y generar texto similar al humano. Impulsan herramientas que la mayoría de nosotros ya usamos: ChatGPT, Claude, Gemini. Pero usarlos a través de un navegador es solo el comienzo.

“Hoy iremos más allá de la interfaz web y aprenderemos cómo integrar estos modelos directamente en tu código Python. Esto abre posibilidades para la automatización, flujos de trabajo personalizados y la creación de tus propias herramientas impulsadas por IA.”

Interactuando con LLMs usando chatlas

Hay varias formas de trabajar con LLMs en Python de forma programática: SDKs de proveedores (OpenAI, Anthropic, Google), o frameworks como LangChain, LlamaIndex y Haystack. chatlas busca un punto intermedio: lo suficientemente simple para comenzar rápidamente, pero lo suficientemente flexible para aplicaciones reales.

“chatlas fue diseñado para hacer que la integración con LLMs sea sencilla. No necesitas aprender abstracciones complejas ni navegar por archivos de configuración. Maneja tareas comunes como el historial de conversación automáticamente, mientras te da acceso a funciones avanzadas cuando las necesites.”

Comenzar toma tres líneas:¹

from chatlas import ChatOllama

chat = ChatOllama(model="gemma3")

chat.chat("Tell me something about Monterrey, Mexico.")

También puedes agregar un system prompt para controlar el comportamiento del modelo — por ejemplo, restringirlo a respuestas en español de no más de tres oraciones:

chat = ChatOllama(model="gemma3",
                  system_prompt="Reply in Spanish using at most three sentences.")

chat.chat("Tell me something about Monterrey, Mexico.")

chatlas funciona en la consola de Python para experimentación rápida, en scripts para automatización, y en notebooks de Jupyter para trabajo exploratorio.

Proveedores y modelos

Un proveedor es una empresa que aloja y sirve modelos (OpenAI, Anthropic, Google). Un modelo es el LLM específico que estás usando (GPT-4, Claude, Gemini). Los modelos se diferencian en varias dimensiones:

Contexto — ¿cuántos tokens puedes darle al modelo?
Velocidad — ¿cuántos tokens por segundo?
Costo — ¿cuánto por millón de tokens?
Inteligencia — capacidad de razonamiento y precisión
Capacidades — visión, llamada de herramientas, salida estructurada, etc.

chatlas soporta APIs comerciales, modelos locales vía Ollama, y servicios empresariales como Bedrock. Lo más importante: cambiar de proveedor solo requiere cambiar la importación (ChatOllama vs ChatAnthropic) y el modelo (gemma3 vs claude-sonnet-4-6) — el resto de tu código permanece prácticamente igual:²

from chatlas import ChatOllama
chat = ChatOllama(model="gemma3")

# or

from chatlas import ChatAnthropic
chat = ChatAnthropic(model="claude-sonnet-4-6",
                     api_key=os.getenv("ANTHROPIC_API_KEY"))

“Esta flexibilidad significa que puedes comenzar con un proveedor y cambiar a otro sin reescribir tu código.”

Llamada de herramientas (tool calling)

Por defecto, los LLMs no tienen acceso a datos en tiempo real. Pregúntales sobre el clima y obtendrás información general — no el pronóstico de hoy. La llamada de herramientas soluciona esto permitiendo que el modelo llame a tus funciones de Python.

La clave es el docstring: le dice al modelo qué hace la función y qué parámetros necesita. chatlas lo convierte automáticamente a un formato que el modelo entiende.

import requests

def get_current_weather(lat: float, lng: float):
    """
    Get the current weather given a latitude and longitude.

    Parameters
    ----------
    lat: The latitude of the location.
    lng: The longitude of the location.
    """
    lat_lng = f"latitude={lat}&longitude={lng}"
    url = f"https://api.open-meteo.com/v1/forecast?{lat_lng}¤t=temperature_2m,wind_speed_10m"
    response = requests.get(url)
    return response.json()["current"]

chat.register_tool(get_current_weather)
chat.chat("How's the weather in Monterrey, Mexico?")

Una vez registrada, el modelo reconoce cuándo necesita datos del clima, llama a la función con las coordenadas correctas, e integra el resultado en una respuesta natural:

# 🔧 tool request
 get_current_weather(lat=25.6866, lng=-100.3161)

# ✅ tool result
 {'temperature_2m': 23.1, 'wind_speed_10m': 4.5}

The current weather in Monterrey is 23.1°C with light winds of 4.5 km/h.

“Este es el poder de la llamada de herramientas — tu LLM ahora puede interactuar con cualquier API o fuente de datos que le proporciones.”

Entrada multimodal

chatlas puede manejar más que solo texto. Pásale un archivo de imagen y hazle preguntas sobre él:

chat = ChatOllama(model="gemma3")

chat.chat(
    chatlas.content_image_file("./images/View_of_Monterrey.jpg"),
    "Can you explain this image? Be concise."
)

Los PDFs funcionan de la misma manera — útil para procesar artículos de investigación, informes o facturas:

chat = ChatAnthropic(model="claude-sonnet-4-6",
                     api_key=os.getenv("ANTHROPIC_API_KEY"))

chat.chat(
    chatlas.content_pdf_file("./images/data-projects-in-monterrey-mexico.pdf"),
    "What are the main findings? Be concise."
)

No todos los modelos soportan todos los tipos de entrada, así que vale la pena revisar la documentación del proveedor — pero los modelos con capacidad de visión y de documentos son cada vez más comunes.

Streaming e historial de chat

El streaming devuelve respuestas fragmento a fragmento a medida que se generan, lo que crea una experiencia más fluida:

stream = chat.stream("My name is Isabella.")
for chunk in stream:
    print(chunk)

El historial de chat se mantiene automáticamente. Más tarde en la misma sesión:

chat.chat("What's my name?")
# → Your name is Isabella!

“No necesitas gestionar el contexto manualmente — simplemente funciona. Esto hace que construir aplicaciones conversacionales sea mucho más simple.”

Juntos, el streaming y el historial de chat persistente son la base de cualquier chatbot.

Ejemplos prácticos

Resumen de documentos en lote

Define los campos que quieres con un modelo de Pydantic, recorre una carpeta de PDFs, y guarda los resultados como un CSV:

from pathlib import Path
from pydantic import BaseModel
import pandas as pd

chat = ChatGoogle(model="gemini-1.5-flash")

class Paper(BaseModel):
    """Extract key information from this research paper."""
    title: str
    authors: list[str]
    year: int
    key_findings: str  # 1-2 sentences

papers = []
for pdf_path in Path("research_papers/").glob("*.pdf"):
    result = chat.chat_structured(
        chatlas.content_pdf_file(pdf_path), data_model=Paper
    )
    papers.append(result.model_dump())

pd.DataFrame(papers).to_csv("paper_summaries.csv", index=False)

“Algo que tomaría horas de trabajo manual se convierte en un script corto que se ejecuta en minutos.”

Construyendo un chatbot con Shiny

chatlas se integra directamente con Shiny for Python. Shiny proporciona la interfaz de chat; chatlas se encarga del LLM:

from chatlas import ChatOllama
from shiny.express import ui

chat = ui.Chat(id="ui_chat")
chat.ui()

chat_model = ChatOllama(model="gemma3:1b")

@chat.on_user_submit
async def handle_user_input():
    response = chat_model.stream(chat.user_input())
    await chat.append_message_stream(response)

Conectando un chatbot a tus propios datos

Los chatbots genéricos (ChatGPT, Claude) no pueden responder preguntas sobre los datos de tu organización. Con chatlas puedes registrar herramientas que consulten tus bases de datos locales, registros de eventos o APIs internas:

EVENTS = [
    {"name": "Python & LLMs Workshop", "date": "2026-05-09",
     "location": "TEC de Monterrey", "attendees": 45, "topic": "chatlas and AI"},
]

def get_upcoming_events(topic: str = None):
    """Get upcoming PyLadies Monterrey events, optionally filtered by topic."""
    return [e for e in EVENTS if topic.lower() in e["topic"].lower()]

chat = ChatAnthropic(model="claude-sonnet-4-5")
chat.register_tool(get_upcoming_events)

chat.chat("What events do we have about AI?")

El modelo llama a la función, obtiene los datos, y responde de forma natural — en este caso incluso cambiando al español para la audiencia de PyLadies Monterrey.

Para un ejemplo completo que combina Shiny, chatlas y llamada de herramientas en un chatbot funcional de PyLadies Monterrey, consulta monterrey_app.py en el repositorio de la charla.

Desplegando chatbots

No lo cubrimos en la charla, pero si quieres desplegar chatbots de Shiny for Python conectados a LLMs con chatlas, Posit Connect Cloud es una opción gratuita. Hay documentación disponible sobre cómo Deploy a LLM-powered Shiny for Python App with Secrets.

Lo que sigue

Una vez que te sientas cómoda con lo básico, hay técnicas poderosas para explorar:

MCP (Model Context Protocol) — un protocolo estandarizado para conectar LLMs a fuentes de datos y herramientas
RAG (Retrieval Augmented Generation) — fundamenta las respuestas en tus propios documentos y bases de conocimiento
Evals — prueba y mide sistemáticamente la calidad y confiabilidad de tu aplicación LLM

Resumen

chatlas hace que conectar Python con LLMs sea sencillo:

Multi-proveedor — alterna entre OpenAI, Anthropic, Google, Ollama y más cambiando solo una línea
Llamada de herramientas — registra cualquier función de Python para que el modelo pueda llamar APIs reales y acceder a datos en vivo
Multimodal — pasa imágenes y PDFs junto con prompts de texto
Streaming — devuelve respuestas fragmento a fragmento para una experiencia de usuario fluida
Con estado — el historial de conversación se rastrea automáticamente
Integración con Shiny — construye interfaces de chat interactivas en unas pocas líneas de código

This summary was generated by Claude Sonnet 4.6 and reviewed by me.

What are Large Language Models?

LLMs are AI models trained on massive amounts of text — books, websites, code — that can understand and generate human-like text. They power tools most of us already use: ChatGPT, Claude, Gemini. But using them through a browser is just the beginning.

“Today we’ll go beyond the web interface and learn how to integrate these models directly into your Python code. This opens up possibilities for automation, custom workflows, and building your own AI-powered tools.”

Interacting with LLMs using chatlas

There are several ways to work with LLMs in Python programmatically: provider SDKs (OpenAI, Anthropic, Google), or frameworks like LangChain, LlamaIndex, and Haystack. chatlas aims for a middle ground: simple enough to get started quickly, but flexible enough for real applications.

“chatlas was designed to make LLM integration straightforward. You don’t need to learn complex abstractions or wade through configuration files. It handles common tasks like conversation history automatically, while still giving you access to advanced features when you need them.”

Getting started takes three lines:³

from chatlas import ChatOllama

chat = ChatOllama(model="gemma3")

chat.chat("Tell me something about Monterrey, Mexico.")

You can also add a system prompt to control the model’s behavior — for example, restricting it to Spanish responses no longer than three sentences:

chat = ChatOllama(model="gemma3",
                  system_prompt="Reply in Spanish using at most three sentences.")

chat.chat("Tell me something about Monterrey, Mexico.")

chatlas works in the Python console for quick experimentation, in scripts for automation, and in Jupyter notebooks for exploratory work.

Providers and models

A provider is a company that hosts and serves models (OpenAI, Anthropic, Google). A model is the specific LLM you’re using (GPT-4, Claude, Gemini). Models differ along several dimensions:

Context — how many tokens can you give the model?
Speed — how many tokens per second?
Cost — how much per million tokens?
Intelligence — reasoning ability and accuracy
Capabilities — vision, tool calling, structured output, etc.

chatlas supports commercial APIs, local models via Ollama, and enterprise services like Bedrock. Crucially, switching providers requires only changing the import (ChatOllama vs ChatAnthropic) and the model (gemma3 vs claude-sonnet-4-6) — the rest of your code stays mostly the same:⁴

from chatlas import ChatOllama
chat = ChatOllama(model="gemma3")

# or

from chatlas import ChatAnthropic
chat = ChatAnthropic(model="claude-sonnet-4-6",
                     api_key=os.getenv("ANTHROPIC_API_KEY"))

“This flexibility means you can start with one provider and switch to another without rewriting your code.”

Tool calling

Out of the box, LLMs don’t have access to real-time data. Ask about the weather and you’ll get general climate information — not today’s forecast. Tool calling fixes this by letting the model call your Python functions.

The key is the docstring: it tells the model what the function does and what parameters it needs. chatlas converts this automatically into a format the model understands.

import requests

def get_current_weather(lat: float, lng: float):
    """
    Get the current weather given a latitude and longitude.

    Parameters
    ----------
    lat: The latitude of the location.
    lng: The longitude of the location.
    """
    lat_lng = f"latitude={lat}&longitude={lng}"
    url = f"https://api.open-meteo.com/v1/forecast?{lat_lng}¤t=temperature_2m,wind_speed_10m"
    response = requests.get(url)
    return response.json()["current"]

chat.register_tool(get_current_weather)
chat.chat("How's the weather in Monterrey, Mexico?")

Once registered, the model recognizes when it needs weather data, calls the function with the right coordinates, and weaves the result into a natural response:

# 🔧 tool request
 get_current_weather(lat=25.6866, lng=-100.3161)

# ✅ tool result
 {'temperature_2m': 23.1, 'wind_speed_10m': 4.5}

The current weather in Monterrey is 23.1°C with light winds of 4.5 km/h.

“This is the power of tool calling — your LLM can now interact with any API or data source you provide.”

Multi-modal input

chatlas can handle more than text. Pass an image file and ask questions about it:

chat = ChatOllama(model="gemma3")

chat.chat(
    chatlas.content_image_file("./images/View_of_Monterrey.jpg"),
    "Can you explain this image? Be concise."
)

PDFs work the same way — useful for processing research papers, reports, or invoices:

chat = ChatAnthropic(model="claude-sonnet-4-6",
                     api_key=os.getenv("ANTHROPIC_API_KEY"))

chat.chat(
    chatlas.content_pdf_file("./images/data-projects-in-monterrey-mexico.pdf"),
    "What are the main findings? Be concise."
)

Not all models support every input type, so it’s worth checking provider documentation — but vision-capable and document-capable models are increasingly common.

Streaming and chat history

Streaming returns responses chunk by chunk as they’re generated, which creates a more responsive experience:

stream = chat.stream("My name is Isabella.")
for chunk in stream:
    print(chunk)

Chat history is maintained automatically. Later in the same session:

chat.chat("What's my name?")
# → Your name is Isabella!

“You don’t need to manually manage context — it just works. This makes building conversational applications much simpler.”

Together, streaming and persistent chat history are the foundation of any chatbot.

Practical examples

Batch document summarization

Define the fields you want with a Pydantic model, loop through a folder of PDFs, and save the results as a CSV:

from pathlib import Path
from pydantic import BaseModel
import pandas as pd

chat = ChatGoogle(model="gemini-1.5-flash")

class Paper(BaseModel):
    """Extract key information from this research paper."""
    title: str
    authors: list[str]
    year: int
    key_findings: str  # 1-2 sentences

papers = []
for pdf_path in Path("research_papers/").glob("*.pdf"):
    result = chat.chat_structured(
        chatlas.content_pdf_file(pdf_path), data_model=Paper
    )
    papers.append(result.model_dump())

pd.DataFrame(papers).to_csv("paper_summaries.csv", index=False)

“Something that would take hours of manual work becomes a short script that runs in minutes.”

Building a chatbot with Shiny

chatlas integrates directly with Shiny for Python. Shiny provides the chat UI; chatlas handles the LLM:

from chatlas import ChatOllama
from shiny.express import ui

chat = ui.Chat(id="ui_chat")
chat.ui()

chat_model = ChatOllama(model="gemma3:1b")

@chat.on_user_submit
async def handle_user_input():
    response = chat_model.stream(chat.user_input())
    await chat.append_message_stream(response)

Connecting a chatbot to your own data

Generic chatbots (ChatGPT, Claude) can’t answer questions about your organization’s data. With chatlas you can register tools that query your local databases, event records, or internal APIs:

EVENTS = [
    {"name": "Python & LLMs Workshop", "date": "2026-05-09",
     "location": "TEC de Monterrey", "attendees": 45, "topic": "chatlas and AI"},
]

def get_upcoming_events(topic: str = None):
    """Get upcoming PyLadies Monterrey events, optionally filtered by topic."""
    return [e for e in EVENTS if topic.lower() in e["topic"].lower()]

chat = ChatAnthropic(model="claude-sonnet-4-5")
chat.register_tool(get_upcoming_events)

chat.chat("What events do we have about AI?")

The model calls the function, gets the data, and responds naturally — in this case even switching to Spanish for the PyLadies Monterrey audience.

For a full example that combines Shiny, chatlas, and tool calling into a working PyLadies Monterrey chatbot, see monterrey_app.py in the talk repo.

Deploying chatbots

We didn’t cover this in the talk, but if you want to deploy Shiny for Python chatbots connected to LLMs with chatlas, Posit Connect Cloud is a free option. Documentation is available on how to Deploy a LLM-powered Shiny for Python App with Secrets.

What’s next

Once you’re comfortable with the basics, there are powerful techniques to explore:

MCP (Model Context Protocol) — a standardized protocol for connecting LLMs to data sources and tools
RAG (Retrieval Augmented Generation) — ground responses in your own documents and knowledge bases
Evals — systematically test and measure your LLM application’s quality and reliability

Summary

chatlas makes it straightforward to connect Python to LLMs:

Multi-provider — swap between OpenAI, Anthropic, Google, Ollama, and more by changing one line
Tool calling — register any Python function so the model can call real APIs and access live data
Multi-modal — pass images and PDFs alongside text prompts
Streaming — return responses chunk by chunk for a responsive user experience
Stateful — conversation history is tracked automatically
Shiny integration — build interactive chat UIs in a few lines of code

Footnotes

Esto requiere que Ollama esté instalado y el modelo gemma3 descargado localmente. Consulta el artículo Setting up local LLMs for R and Python para instrucciones de configuración.↩︎
A diferencia de ChatOllama, ChatAnthropic requiere una clave de API porque los modelos de Anthropic son un servicio de pago. Para saber cómo almacenar y acceder a las claves de API de forma segura, consulta How to set and access environment variables in Python.↩︎
This requires Ollama to be installed and the gemma3 model downloaded locally. See the Setting up local LLMs for R and Python blog post for setup instructions.↩︎
Unlike ChatOllama, ChatAnthropic requires an API key because Anthropic’s models are a paid service. For how to store and access API keys securely, see How to set and access environment variables in Python.↩︎

Getting Started with Quarto: A Hands-On Workshop

Isabella Velásquez — Thu, 30 Apr 2026 00:00:00 GMT

Event Website Exercises Repo

Details

👥 R User Group RNVSU
📆 30 April 2026 // 09:30 AM PHT
💻️ Virtual

Description

Join us for a virtual, hands-on workshop on Quarto, a tool for creating reproducible documents, reports, and dashboards with R, Python, and more. The next-generation of R Markdown, Quarto makes it easy to combine code, narrative, and results into polished, shareable outputs. In this session, you’ll learn the basics of getting started, explore common workflows, and see how Quarto can help you create clear, reproducible work for the web, presentations, and more.

Website ↗

Find the materials, exercises, and slides on the website.

The Invisible Work of Data Science Projects

Isabella Velásquez — Thu, 16 Apr 2026 00:00:00 GMT

Event Slides Repo Recording

Details

🐺 Northern Illinois University College of Business
📆 16 April 2026 // 3:00 PM CT
📍️ DeKalb, IL

Description

What does it mean to inherit systems you didn’t build? This session examines the procedural habits required to manage data and systems that aren’t our own. We will break down strategies for maintaining high performance when working with everything from unfamiliar tabular data to the black-box nature of large language models.

Slides

Photo gallery EJS created by Mickaël Canouil.

Working smarter with {dplyr} 1.2.0

Isabella Velásquez — Wed, 18 Mar 2026 00:00:00 GMT

Event Slides Repo Recording

Details

👥 R-Ladies Rome
📆 18 March 2026 // 01:00 PM ET
💻️ Virtual

Description

The tidyverse keeps evolving, and {dplyr} 1.2.0 brings a set of new tools that make data manipulation even more expressive and flexible. Whether you regularly work with R and the tidyverse, or you’re looking to sharpen your data wrangling skills, this session will help you better understand the design philosophy behind the latest {dplyr} release and how to apply it effectively.

Slides

Recording

Summary

This summary was generated by Claude Sonnet 4.6 and reviewed by me.

Today’s data

We’ll use salmonid mortality data from TidyTuesday, published by the Norwegian Veterinary Institute. The dataset covers monthly mortality data from 2020.

“The data is going to be shared saved in an object called monthly_losses_data. And if we read in that CSV and take a look at the first few rows, you’ll notice that there are nine columns that cover things like species, date, geo group, region, losses, and a variety of variables that describe how those losses happened. And so just a really nice data set to practice some of the functions that we’re going to be taking a look at.”

monthly_losses_data <-
  readr::read_csv('https://raw.githubusercontent.com/rfordatascience/tidytuesday/main/data/2026/2026-03-17/monthly_losses_data.csv')

Rows: 2808 Columns: 9
── Column specification ────────────────────────────────────────────────────────
Delimiter: ","
chr  (3): species, geo_group, region
dbl  (5): losses, dead, discarded, escaped, other
date (1): date

ℹ Use `spec()` to retrieve the full column specification for this data.
ℹ Specify the column types or set `show_col_types = FALSE` to quiet this message.

head(monthly_losses_data)

# A tibble: 6 × 9
  species date       geo_group region losses   dead discarded escaped other
                             
1 salmon  2020-01-01 area      1       31425  28126      3299       0     0
2 salmon  2020-01-01 area      2      324116 277888     46113       0   115
3 salmon  2020-01-01 area      3      844829 776983     63770       0  4076
4 salmon  2020-01-01 area      4      676852 623159     51823       0  1870
5 salmon  2020-01-01 area      5      109269  97627     11424       0   218
6 salmon  2020-01-01 area      6      548921 531193     15710       0  2018

A quick dplyr refresher

dplyr is a grammar of data manipulation, providing a consistent set of verbs that help you solve the most common data manipulation challenges.

“dplyr is a core member of the tidyverse which is a curated collection of R packages specifically for data science. All the tidyverse packages share this opinionated philosophy that data should be in what’s called a tidy format — each variable is a column, each observation is a row, each value is a cell.”

Here are the core functions we’ll use as a foundation:

arrange() — changes the ordering of rows:

monthly_losses_data |> arrange(date)

select() — picks variables based on their names:

monthly_losses_data |>
  select(species, dead, discarded, escaped, other)

summarise() — reduces multiple values down to a single summary:

monthly_losses_data |>
  summarize(mean_losses = mean(losses))

group_by() — performs any operation “by group”:

monthly_losses_data |>
  group_by(region) |>
  summarize(mean = mean(losses))

mutate() — adds new variables that are functions of existing variables:

monthly_losses_data |>
  mutate(total = dead + discarded + escaped + other)

case_when() — checks each condition in order and assigns a value based on the first match:

monthly_losses_data |>
  mutate(loss_rating =
           case_when(losses > 100000 ~ "High",
                     losses < 100000 ~ "Low"))

filter() — picks cases based on their values:

monthly_losses_data |> filter(region == "1")

“dplyr is a grammar. This kind of syntax — taking your data frame, using a pipe, using a verb, and then specifying the columns — that’s the general syntax that we’ll see throughout this presentation.”

dplyr 1.2.0

Everything covered below is explored in great detail in the dplyr 1.2.0 blog post by Davis Vaughan.

`filter_out()`

The problem

Have you ever stared at filter(region == "1") and wondered: am I keeping Region 1 or dropping it?

“The original filter function was optimized for keeping rows. And often, because it was the quickest tool at our disposal or the only tool that we had, we may have forced it to drop rows using negative logic.”

Here’s what that looks like in practice. Say we have a small dataset with an NA in the losses column:

monthly_losses_NA

# A tibble: 5 × 3
  species region losses
        
1 salmon  1       31425
2 salmon  2      324116
3 salmon  3      844829
4 salmon  3      676852
5 salmon  3          NA

We want to drop rows where region == 3 and losses > 700000. Using the traditional approach:

monthly_losses_NA |>
  filter(!(region == 3 & losses > 700000))

# A tibble: 3 × 3
  species region losses
        
1 salmon  1       31425
2 salmon  2      324116
3 salmon  3      676852

The row with NA losses was silently dropped too — not what we wanted. To handle NAs correctly with filter(), we’d need:

monthly_losses_NA |>
  filter(
    !((region == 3 & !is.na(region)) &
             (losses > 700000 & !is.na(losses)))
    )

# A tibble: 4 × 3
  species region losses
        
1 salmon  1       31425
2 salmon  2      324116
3 salmon  3      676852
4 salmon  3          NA

The solution: `filter_out()`

“Rather than trying to think through negations and logic and things like that, just remember: use filter() to keep rows, use filter_out() to drop rows.”

monthly_losses_NA |>
  filter_out(region == 3 & losses > 700000)

# A tibble: 4 × 3
  species region losses
        
1 salmon  1       31425
2 salmon  2      324116
3 salmon  3      676852
4 salmon  3          NA

dplyr with filter_out() assumes that if a row is NA or unknown, you probably don’t want to drop it — so it only drops rows that definitively meet your criteria.

`when_any()` and `when_all()`

The problem

Combining multiple OR conditions with filter() leads to deeply nested, error-prone code:

monthly_losses_filters |>
  filter(
    (region %in% c("7", "8") & losses > 400000) |
           (region %in% c("2", "9") & losses > 300000)
    )

# A tibble: 4 × 3
# Groups:   region [4]
  species region losses
        
1 salmon  2      324116
2 salmon  7      475115
3 salmon  8      442659
4 salmon  9      311127

“It starts to indent. You have to remember where you put your parentheses because there are a lot of them. As you can imagine, it can just get very unwieldy to write something like this, especially if you have many OR statements.”

The solution: `when_any()` and `when_all()`

Use when_any() for OR conditions and when_all() for AND conditions:

monthly_losses_filters |>
  filter(
    when_any(
      (region %in% c("7", "8") & losses > 400000),
      (region %in% c("2", "9") & losses > 300000)
    )
  )

# A tibble: 4 × 3
# Groups:   region [4]
  species region losses
        
1 salmon  2      324116
2 salmon  7      475115
3 salmon  8      442659
4 salmon  9      311127

monthly_losses_filters |>
  filter(
    when_all(
      region %in% c("7", "8"),
      losses > 400000
    )
  )

# A tibble: 2 × 3
# Groups:   region [2]
  species region losses
        
1 salmon  7      475115
2 salmon  8      442659

“when_any() and when_all() continue this theme of intent-based coding — you lead with exactly what it is that you want. Your requirements are just separated by a comma, everything is indented at the same level, and hopefully much easier for a colleague to follow your logic.”

Both helpers also work with the new filter_out().

New recoding and replacing functions

Some background

Recoding used to involve choosing between if/else, case_when(), recode(), or recode() + rlang’s !!! splicing operator — each with its own quirky syntax.

“There are so many ways of recoding — if/else, case_when, recode, recode with rlang — and each one is very specific in how it works, each one brings their own set of syntax, and it could get really confusing.”

Recoding vs. replacing

Two important distinctions:

Recoding — creating an entirely new column using values from an existing column
Replacing — partially updating an existing column with new values

The new family

dplyr 1.2.0 introduces three new functions alongside case_when():

Task	Match by	Function
Recode	Conditions	`case_when()`
Recode	Values	`recode_values()`
Replace	Conditions	`replace_when()`
Replace	Values	`replace_values()`

`recode_values()`

po_mapping <- list(
  "1" = "Jæren", "2" = "Ryfylke", "3" = "Sotra",
  "4" = "Stadt", "5" = "Hustadvika", "6" = "Nordmøre",
  "7" = "Nord-Trøndelag", "8" = "Bodø", "9" = "Vestlfjorden",
  "10" = "Andfjorden", "11" = "Kvaløya",
  "12" = "Vest-Finnmark", "13" = "Øst-Finnmark"
)

monthly_losses_data |>
  select(species, geo_group, region, losses) |>
  filter(geo_group == "area") |>
  mutate(
    production_area = region |>
      recode_values(
        "1" ~ "Jæren",
        "2" ~ "Ryfylke",
        # ...
        "13" ~ "Øst-Finnmark",
        unmatched = "error"
      )
  )

The unmatched = "error" argument is particularly useful:

“Say I was unaware that my dataset actually has 14 regions instead of 13 and I didn’t give it something to recode for region 14. I could put unmatched = "error". And when I run this, it will actually stop the code and let me know immediately — hey, you didn’t match your list to everything. It’s a good way of cleaning up your pipeline and avoiding those kind of silent errors.”

You can also use a lookup table instead of listing values inline:

po_mapping_tibble <-
  tibble::enframe(po_mapping, name = "from", value = "to") |>
  unnest(to)

monthly_losses_data |>
  select(species, geo_group, region, losses) |>
  filter(geo_group == "area") |>
  mutate(production_area =
           recode_values(region,
                         from = po_mapping_tibble$from,
                         to = po_mapping_tibble$to)
         )

# A tibble: 1,512 × 5
   species geo_group region losses production_area
                         
 1 salmon  area      1       31425 Jæren          
 2 salmon  area      2      324116 Ryfylke        
 3 salmon  area      3      844829 Sotra          
 4 salmon  area      4      676852 Stadt          
 5 salmon  area      5      109269 Hustadvika     
 6 salmon  area      6      548921 Nordmøre       
 7 salmon  area      7      231487 Nord-Trøndelag 
 8 salmon  area      8      442659 Bodø           
 9 salmon  area      9      311127 Vestlfjorden   
10 salmon  area      10     288849 Andfjorden     
# ℹ 1,502 more rows

`replace_values()`

Use replace_values() when you want to update specific values within an existing column — all other values stay the same:

monthly_losses_data_po |>
  mutate(production_area = production_area |>
           replace_values(
             "Nordmøre" ~ "Nordmøre + Sør-Trøndelag",
             "Nord-Trøndelag" ~ "Nord-Trøndelag + Bindal"
             )
         )

# A tibble: 1,512 × 5
   species geo_group region losses production_area         
                                  
 1 salmon  area      1       31425 Jæren                   
 2 salmon  area      2      324116 Ryfylke                 
 3 salmon  area      3      844829 Sotra                   
 4 salmon  area      4      676852 Stadt                   
 5 salmon  area      5      109269 Hustadvika              
 6 salmon  area      6      548921 Nordmøre + Sør-Trøndelag
 7 salmon  area      7      231487 Nord-Trøndelag + Bindal 
 8 salmon  area      8      442659 Bodø                    
 9 salmon  area      9      311127 Vestlfjorden            
10 salmon  area      10     288849 Andfjorden              
# ℹ 1,502 more rows

`replace_when()`

case_when() requires a .default argument, otherwise unmatched rows become NA. replace_when() knows you only intend to replace some values — so no .default needed:

monthly_losses_data |>
  slice(1:4) |>
  select(species, region, losses) |>
  mutate(losses =
           replace_when(losses,
                        losses > 500000 ~ 500000)
         )

# A tibble: 4 × 3
  species region losses
        
1 salmon  1       31425
2 salmon  2      324116
3 salmon  3      500000
4 salmon  4      500000

Additional notes

case_match() has been soft deprecated — it has been fully replaced by recode_values() and replace_values().
Speed improvements — core functions like if_else() and case_when() have been rewritten in C using the vctrs framework, bringing speed gains across the tidyverse. See the dplyr performance blog post.
Updating your LLM — because dplyr 1.2.0 is so new, your AI assistant may not know about filter_out(), when_any(), or the new recode functions. Give it context by pasting the release notes or blog post into the conversation, adding a CLAUDE.md file, or using an MCP server.

Community feedback matters

“dplyr 1.2.0 is a direct result of community feedback. The authors are incredibly active on platforms like Bluesky and they don’t just post updates — they also ask for your thoughts. And the reason that dplyr is more efficient, faster, and everything is because the people building it are listening to the people using it. So if you ever find yourself at a point where you have a really messy workaround, I highly encourage you to share it — because you might just inspire the next big feature in 1.3.0.”

Discussions happen in the Tidyups repo on GitHub, where the tidyverse team proposes ideas and invites community comment.

Summary

dplyr 1.2.0 introduces:

filter_out() — the missing complement to filter(), for dropping rows cleanly and safely
when_any() and when_all() — helpers for expressing OR and AND conditions more clearly inside filter() and filter_out()
recode_values(), replace_values(), and replace_when() — a complete, coherent family for recoding and replacing values

To upgrade:

install.packages("pak")
pak::pak("dplyr")

Categorical Survey of Complex Survey Data in R

Rebecca Powell — Fri, 21 Nov 2025 00:00:00 GMT

Event Slides Repo

Details

👥 MAPOR 2025
📆 21 November 2025 // 08:30 AM CT
🌆️ Chicago, IL

Description

This interactive short course will introduce how to analyze categorical survey data in R. We will cover the R functions needed to create the survey design object to account for the sampling design, obtain weighted proportions from survey data, and conduct tests and simple linear regression models. Throughout the course, you will get hands-on experience using data from the American National Election Studies. We will be using Posit Cloud, so you do not need to have R or RStudio preinstalled on your computer. For the best learning experience, we recommend you have prior experience with R and the tidyverse, including familiarity with summarize() and group_by().

Slides

Creating Polished, Branded Documents with Quarto

Isabella Velásquez — Tue, 04 Nov 2025 00:00:00 GMT

Event Website Exercises Repo Recording

Details

👥 R/Pharma 2025
📆 04 November 2025 // 01:00 PM ET
💻️ Virtual

Description

Join us for a hands-on, one-day workshop at R/Pharma, where we’ll explore the versatility of Quarto output formats. You will learn how to create dynamic websites, professional PDF documents, engaging presentations, and interactive dashboards using Quarto. This workshop highlights Quarto’s powerful theming capabilities, including the new support for brand.yml, which ensures that your work maintains a professional and cohesive style across all formats.

Website ↗

Find the materials, exercises, and slides on the website.

Recording

Automating Repetitive Reports with Quarto

Isabella Velásquez — Fri, 24 Oct 2025 00:00:00 GMT

Event Slides Repo Exercises

Details

👥 MAPOR Fall Webinar Series 2025
📆 24 October 2025 // 12:00 PM CT
💻️ Virtual

Description

Writing reports often means repeating the same tasks: copying results, updating text, and exporting to different formats. Quarto is a technical publishing tool that streamlines this process by combining text, code, and visuals together in one document. Instead of rewriting the same report with minor changes, you can generate multiple versions from a single template. In this webinar, we’ll walk through practical examples, such as client-specific reports and recurring updates, to show how Quarto helps you save time, reduce errors, and deliver consistent, professional reports.

Slides

Positron for RStudio Users: A Gentle Introduction

Isabella Velásquez — Thu, 09 Oct 2025 00:00:00 GMT

Event Slides Recording

Details

👥 R-Ladies Gaborone
📆 09 October 2025 // 11:00 AM CT
💻️ Virtual

Description

Curious about Positron, the new open-source data science IDE from Posit? This session will walk RStudio users through the basics of Positron, highlight familiar features, and show what’s new. Whether you’re exploring it for the first time or considering a switch, you’ll leave with a clear sense of how Positron can fit into your workflow.

Slides

Recording

Branded Websites, Presentations, Dashboards, and PDFs with Quarto

Isabella Velásquez — Tue, 16 Sep 2025 00:00:00 GMT

Event Website Repo Exercises

Details

👥 posit::conf(2025)
📆 16 September 2025 // 09:00 AM ET
🍑️ Atlanta, GA

Description

Join us for a hands-on, one-day workshop at posit::conf(2025), where we’ll explore the versatility of Quarto output formats. Designed for data scientists, analysts, and content creators, this immersive session will teach you how to craft cohesive reports and presentations while refining your workflow with Quarto’s latest features.

You will learn how to create dynamic websites, professional PDF documents, engaging presentations, and interactive dashboards using Quarto. This workshop highlights Quarto’s powerful theming capabilities, including the new support for brand.yml, which ensures that your work maintains a professional and cohesive style across all formats.

By the end of the session, you’ll be equipped to:

Build and deploy Quarto websites.
Generate professional presentations and PDF reports.
Create interactive dashboards for data visualization and reporting.
Use brand.yml to define and apply consistent theming across all outputs.

Whether you’re looking to enhance your personal projects or streamline organizational outputs, this workshop will equip you with the tools to create polished, professional results.

Website

Complex Survey Data Analysis: A Tidy Introduction with {srvyr} and {survey}

Stephanie Zimmer — Fri, 08 Aug 2025 00:00:00 GMT

Event Website Repo

Details

👥 useR! 2025
📆 08 August 2025 // 01:00 PM ET
💙️ Duke University

Description

This interactive tutorial will introduce how to conduct analysis of survey data in R. We will first introduce a unifying workflow of tidy survey analysis in R for analysis of survey microdata with weights. We will cover topics of descriptive analysis, including functions to obtain weighted proportions, means, quantiles, and correlations from survey data. Then, we will discuss some statistical testing, including t-tests for comparing means and χ-squared tests for comparing proportions. Finally, we will discuss common probability sampling designs and how to create the survey design objects in R to account for the sampling design. The tutorial will include time for exercises using data from the 2020 American National Election Study and the 2020 Residential Energy Consumption Survey, so you can get hands-on experience with the functions. We will be using Posit Cloud, so you do not need to have R or RStudio preinstalled on your computer. For the best learning experience, we recommend you have some prior experience with R and the tidyverse, including familiarity with mutate(), summarize(), count(), and group_by().

Website

Quarto—To Tell Your Story with Data

Isabella Velásquez — Thu, 26 Jun 2025 00:00:00 GMT

Event Website Exercises Repo Recording

Details

👥 Government Advances in Statistical Programming (GASP) 2025
📆 26 June 2025 // 10:30 AM ET
💻️ Virtual

Description

Join us for a 75-minute introduction to Quarto, the next-generation scientific and technical publishing system. In this workshop, you’ll learn the fundamentals of Quarto. We’ll cover document creation, code integration, and output customization, equipping you to build your own Quarto documents.

Website

Recording

Build Automated, Tailored Marketing Dashboards for Optimized Marketing Spend

Isabella Velásquez — Wed, 25 Jun 2025 00:00:00 GMT

Event Slides Repo Recording

Details

👥 End-to-End Workflow With Posit Team
📆 25 June 2025 // 11:00 AM ET
💻️ Virtual

Description

Scenario: Imagine the weekly scramble at DemoCo. Isabella, a lonely Marketing analyst, spends hours every Friday manually compiling marketing lead performance data from Salesforce, website logs, and event records into a sprawling Excel report. The tedious, redundant process is both a time sink and a bottleneck.

Marketing Leadership, who need to identify top-performing platforms, find the mass amount of information in the report confusing. They constantly return to Isabella for clarification or, even worse, don’t reach back out and make misinformed decisions on critical budget allocation. Determined, Isabella decides it’s finally time to automate and tailor this critical dashboard, and save headaches for both Leadership and herself.

In this demo, you will learn how to:

Transform redundant, manual, error-prone data compilation into an automated lead performance dashboard with Shiny
Integrate diverse marketing data sources for a holistic view
Build tailored marketing KPI dashboards that address Leadership’s specific questions
Use drill-downs, data visualizations, and LLM-powered summaries to reduce data overload and clarify complex takeaways instantly
Provide flexibility in dashboard functionality to meet diverse preferences and needs, from pre-selected insights derived directly from the data to implementing an LLM-powered analytics option

Slides

Recording

Choosing the right tool for interactive dashboards: flexdashboard, Quarto, and Shiny

Isabella Velásquez — Thu, 10 Apr 2025 00:00:00 GMT

Event Slides Repo

Details

🔔 ShinyConf 2025
📆 10 April 2025 // 07:10 AM CT
💻️ Virtual

Description

The landscape of interactive dashboards is rich for R and Python users thanks to powerful tools like flexdashboard and Shiny. The release of Quarto v1.5 introduced built-in dashboard capabilities, presenting even more exciting possibilities. In this talk, we’ll compare each tool and provide practical heuristics to help you select the best option for your needs, whether you’re building lightweight reports, dynamic web apps, or something in between.

Slides

Brand your Quarto projects with brand.yml

Isabella Velásquez — Wed, 12 Mar 2025 00:00:00 GMT

Event Slides Repo Recording

Details

🔔 R-Ladies Philly
📆 12 March 2025 // 11:00 AM CT
💻️ Virtual

Description

Maintaining a consistent brand identity across data science outputs is essential for clear communication and a professional image. This talk introduces brand.yml, a powerful new tool designed to streamline adherence to organizational style guides within the Quarto publishing system. brand.yml simplifies the creation of visually consistent materials that perfectly align with your organization’s brand guidelines in HTML reports, presentations, websites, and dashboards.

We’ll explore how brand.yml allows you to define your brand’s visual identity, including colors, fonts, logos, and more, in a single, centralized location. You will learn how to integrate this configuration file into your Quarto projects, automatically applying the defined style guide to various outputs like reports, presentations, websites, and more. Beyond basic integration, I’ll share practical tips and demonstrate tools that simplify the process of designing and managing your brand.yml file to make brand customization even easier.

Join us to discover how brand.yml can elevate your Quarto documents to a new level of professionalism to ensure that your work is more impactful and on-brand.

Slides

Recording

Tidy Data, Weighted Insights: Analyzing Complex Survey Data in R

Stephanie Zimmer — Tue, 25 Feb 2025 00:00:00 GMT

Event Slides Recording

Details

👥 R-Ladies Amsterdam and R-Ladies RTP
📆 25 February 2025 // 11:00 AM CT
💻️ Virtual

Description

Surveys are powerful tools, but to ensure the accurate interpretation of results, they require specific analysis methods. With the {srvyr} package and {tidyverse} family of functions, we are able to analyze survey data with weights to derive meaningful results. Our new book, Exploring Complex Survey Data Analysis Using R, goes through how to do this step-by-step. You can view the book here: https://tidy-survey-r.github.io/tidy-survey-book/.

Slides

Recording

Interactive R, Python, and Shiny in the Browser with Quarto and Shinylive

Isabella Velásquez — Fri, 21 Feb 2025 00:00:00 GMT

Event Slides Repo Recording

Details

🏛️ R-Ladies Rome
📆 21 February 2025 // 11:00 AM CT
💻️ Virtual

Description

Discover new ways to share R, Python, and Shiny projects using Quarto Live and Shinylive, no server required!

These tools bring R, Python, and Shiny applications to life directly in the browser. Your audience can open a web page and instantly run code or interact with Shiny apps without needing any setup.

Quarto Live allows you to embed interactive code blocks, exercises with hints and solutions, and dynamic visualizations within static HTML documents. Powered by WebAssembly, it brings interactivity to your Quarto documents.

Shinylive transforms Shiny apps into fully browser-based experiences.

In this talk, you’ll learn how to use these tools to create engaging, interactive documents, dashboards, and educational content that anyone can access, even if they do not have R or Python installed. I look forward to seeing you there!

Slides

Recording

From Notebooks to Dashboards with Quarto

Isabella Velásquez — Mon, 23 Sep 2024 00:00:00 GMT

Event Website Repo Exercises

Details

👥 Small Data SF 2024
📆 23 September 2024 // 1:00 PM PT
🌉️ San Francisco, CA

Description

Quarto is an innovative, open-source publishing system from Posit that transforms Jupyter Notebooks and plain markdown into polished, professional outputs. This workshop will show how Quarto helps data scientists create high-quality, shareable dashboards with static and interactive features following an accessible and reproducible workflow.

Website

Using pins for Shiny with ever-changing data

Isabella Velásquez — Wed, 28 Aug 2024 00:00:00 GMT

Event Slides Repo Recording

Details

👥 RStudio Enterprise Community Meetup
📆 28 August 2024 // 11:00 AM CT
💻️ Virtual

Description

Do you manage constantly changing data and need your Shiny app to automatically update?

On August 28th at 11 am ET, Isabella Velásquez demonstrated a streamlined workflow for handling frequently updated datasets in Shiny. You’ll see how to simplify your process for keeping dynamic data current and how to reflect those changes in your app or dashboard.

Slides

Recording

Quarto Dashboards

Isabella Velásquez — Thu, 18 Jul 2024 00:00:00 GMT

Event Slides Repo Recording

Details

👥 R-Ladies Rome
📆 18 July 2024 // 11:00 AM CT
💻️ Virtual

Description

In this workshop, you’ll dive into the world of Quarto, exploring how to create dynamic and interactive dashboards for data visualization. Whether you’re a beginner or seasoned developer, this session promises to enhance your skills and empower you with practical knowledge.

%>% dreams

Skills 101

Details

Description

Recording

Connecting Python with LLMs

Details

Description

Slides

Summary

¿Qué son los modelos de lenguaje grandes?

Interactuando con LLMs usando chatlas

Proveedores y modelos

Llamada de herramientas (tool calling)

Entrada multimodal

Streaming e historial de chat

Ejemplos prácticos

Resumen de documentos en lote

Construyendo un chatbot con Shiny

Conectando un chatbot a tus propios datos

Desplegando chatbots

Lo que sigue

Resumen

What are Large Language Models?

Interacting with LLMs using chatlas

Providers and models

Tool calling

Multi-modal input

Streaming and chat history

Practical examples

Batch document summarization

Building a chatbot with Shiny

Connecting a chatbot to your own data

Deploying chatbots

What’s next

Summary

Footnotes

Getting Started with Quarto: A Hands-On Workshop

Details

Description

Website ↗

The Invisible Work of Data Science Projects

Details

Description

Slides

Working smarter with {dplyr} 1.2.0

Details

Description

Slides

Recording

Summary

Today’s data

A quick dplyr refresher

dplyr 1.2.0

filter_out()

The problem

The solution: filter_out()

when_any() and when_all()

The problem

The solution: when_any() and when_all()

New recoding and replacing functions

Some background

Recoding vs. replacing

The new family

recode_values()

replace_values()

replace_when()

Additional notes

Community feedback matters

Summary

Links

Categorical Survey of Complex Survey Data in R

Details

Description

Slides

Creating Polished, Branded Documents with Quarto

Details

Description

Website ↗

Recording

`filter_out()`

The solution: `filter_out()`

`when_any()` and `when_all()`

The solution: `when_any()` and `when_all()`

`recode_values()`

`replace_values()`

`replace_when()`