DEV Community: RoyserVillanueva

Beyond the Basics: Streamlit, Dash, and Bokeh for Interactive Dashboards

RoyserVillanueva — Wed, 08 Jul 2026 04:25:45 +0000

When we talk about data visualization and dashboards, enterprise tools like Tableau or PowerBI usually dominate the conversation. However, for Data Scientists and Developers, these GUI-based tools can feel restrictive. What if you need integration with machine learning models, custom UI logic, or CI/CD deployments?

This is where three powerful Python libraries come into play: Streamlit, Dash, and Bokeh. In this article, we'll explore the differences between these frameworks, build a basic financial dashboard with each one, and automate their deployment to the cloud using Docker and GitHub Actions.

The Contenders: Streamlit vs. Dash vs. Bokeh

1. Streamlit (The Sprinter)

Streamlit turns data scripts into shareable web apps in minutes. Everything in pure Python. No frontend experience required.

Best for: Rapid prototyping, internal tools, and quick data exploration.
Strengths: Incredibly low learning curve, completely reactive script execution.
Weakness: The "re-run everything" model can be inefficient for complex applications.

2. Plotly Dash (The Architect)

Dash is built on Flask, Plotly.js, and React.js. It requires more boilerplate than Streamlit but offers enterprise-grade customization.

Best for: Production-ready analytical dashboards with complex layouts and advanced interactivity.
Strengths: Highly customizable UI, callback-based architecture ideal for scaling.
Weakness: Steeper learning curve and more boilerplate code.

3. Bokeh (The Artist)

Bokeh focuses on creating high-performance interactive visualizations for modern browsers. Its strength lies in granular control over every chart element.

Best for: Large datasets, streaming data, and highly customized visualizations.
Strengths: Fine-grained control over visualization, excellent for large volumes of data.
Weakness: Can be more verbose for building complete dashboard layouts.

Building a Real Example: Stock Market Dashboard

We'll create a stock price explorer with each tool. Let's start with the fastest one.

Streamlit: The Minutes-to-Dashboard Solution

This script downloads historical stock data, visualizes it, and calculates moving averages interactively.

# streamlit_app.py
import streamlit as st
import pandas as pd
import numpy as np
import altair as alt

st.set_page_config(page_title="Financial Dashboard", layout="wide")
st.title("📈 Interactive Financial Explorer")
st.markdown("Built with **Streamlit** for rapid prototyping.")

# Sidebar for user inputs
st.sidebar.header("Parameters")
ticker = st.sidebar.selectbox("Select Asset", ("AAPL", "GOOGL", "MSFT", "BTC-USD"))
days = st.sidebar.slider("Number of days", 10, 365, 100)
ma_window = st.sidebar.number_input("Moving Average Window", 5, 50, 20)

# Simulated data (replace with real API)
@st.cache_data
def get_data(ticker, days):
    dates = pd.date_range(end=pd.Timestamp.today(), periods=days)
    prices = np.random.normal(loc=150, scale=10, size=days)
    df = pd.DataFrame({'Date': dates, 'Price': prices})
    df.set_index('Date', inplace=True)
    return df

data = get_data(ticker, days)
data['Moving Average'] = data['Price'].rolling(window=ma_window).mean()

# Visualization with Altair
st.subheader(f"Price History for {ticker}")
chart = alt.Chart(data.reset_index()).mark_line().encode(
    x='Date',
    y='Price'
)
st.altair_chart(chart, use_container_width=True)

# Raw Data
with st.expander("Show Raw Data"):
    st.dataframe(data.tail(10))

Run locally:

pip install streamlit pandas numpy altair
streamlit run streamlit_app.py

Dash: The Structured Dashboard

Dash requires a more defined structure with layouts and callbacks.

# app.py
import os
from dash import Dash, html, dcc, Input, Output
import plotly.express as px
import pandas as pd
import numpy as np

# Sample data
df = pd.DataFrame({
    'Category': ['A', 'B', 'C', 'A', 'B', 'C'],
    'Sales': [10, 15, 7, 12, 9, 20]
})

app = Dash(__name__)
server = app.server  # For Gunicorn

app.layout = html.Div([
    html.H1('📊 Dash Dashboard'),
    html.Label('Select Category:'),
    dcc.Dropdown(
        id='category-dropdown',
        options=[{'label': 'All', 'value': 'All'}] + 
                [{'label': cat, 'value': cat} for cat in df['Category'].unique()],
        value='All'
    ),
    dcc.Graph(id='sales-chart')
])

@app.callback(
    Output('sales-chart', 'figure'),
    Input('category-dropdown', 'value')
)
def update_chart(selected_category):
    filtered_df = df if selected_category == 'All' else df[df['Category'] == selected_category]
    fig = px.bar(filtered_df, x='Category', y='Sales', title='Sales by Category')
    return fig

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=int(os.environ.get('PORT', 8050)))

Run locally:

pip install dash pandas plotly
python app.py

Bokeh: The Interactive Visualization

Bokeh focuses on generating interactive plots with its own server.

# main.py
from bokeh.plotting import figure
from bokeh.io import curdoc
import numpy as np

# Sample data
x = np.linspace(0, 10, 100)
y = np.sin(x) + np.random.normal(0, 0.1, 100)

p = figure(title='Bokeh - Interactive Visualization', 
           x_axis_label='X', y_axis_label='Y')
p.line(x, y, legend_label='Without noise', line_width=2)
p.circle(x, y, legend_label='With noise', size=5, color='red', alpha=0.5)

curdoc().add_root(p)

Run locally:

pip install bokeh numpy
bokeh serve --show main.py

Deploying to the Cloud with CI/CD

To take these dashboards to production, we'll containerize them with Docker and automate deployment using GitHub Actions.

Dockerfile (for Dash and Bokeh)

FROM python:3.11-slim

WORKDIR /app

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY . .

EXPOSE 8050  # Port for Dash
# For Bokeh use EXPOSE 5006

CMD ["gunicorn", "--bind", "0.0.0.0:8050", "--workers", "1", "--threads", "8", "app:server"]

requirements.txt

dash==2.14.0
pandas==2.2.0
plotly==5.18.0
gunicorn==21.2.0

GitHub Actions: CI/CD Pipeline

This workflow automates building and deploying to Google Cloud Run:

# .github/workflows/deploy-cloudrun.yml
name: CI/CD - Cloud Run

on:
  push:
    branches: [ main ]

jobs:
  build-and-deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3

      - name: Configure GCloud
        uses: google-github-actions/setup-gcloud@v1
        with:
          service_account_key: ${{ secrets.GCP_SA_KEY }}
          project_id: ${{ secrets.GCP_PROJECT_ID }}

      - name: Build and push image
        run: |
          gcloud builds submit --tag gcr.io/${{ secrets.GCP_PROJECT_ID }}/dash-app:$GITHUB_SHA

      - name: Deploy to Cloud Run
        uses: google-github-actions/deploy-cloudrun@v1
        with:
          service: dash-app
          image: gcr.io/${{ secrets.GCP_PROJECT_ID }}/dash-app:$GITHUB_SHA
          region: us-central1

Simplified Deployment with Streamlit Cloud

For Streamlit, deployment is even simpler: just connect your GitHub repository at share.streamlit.io and get a public URL in seconds.

Alternative Deployment Options:

Heroku: Supports all three frameworks with simple Procfile configuration
AWS Elastic Beanstalk: Great for enterprise deployments
PythonAnywhere: Budget-friendly option for smaller projects

Conclusion: Which One Should You Choose?

Choose Streamlit if: You're a data scientist who needs to build an interactive tool quickly. Perfect for prototypes, internal tools, and ML demos.
Choose Dash if: You're building a complex, production-ready application requiring specific layout design, multi-page functionality, and robust state management.
Choose Bokeh if: Your primary need is highly interactive and performant visualizations, especially with large datasets or streaming data.

All these tools are open-source, Python-based, and can be deployed to the cloud, turning your local experiments into shareable, scalable projects.

MCP Servers: The Bridge Connecting Your AI to the Real World

RoyserVillanueva — Wed, 08 Jul 2026 03:36:46 +0000

Imagine being able to ask your AI assistant to review your code on GitHub, query a database, or draft a report in your favorite productivity tool, all from a single conversation. That's exactly what the Model Context Protocol (MCP) makes possible.

An MCP Server acts as a universal translator. It allows your AI client (like Claude, VSCode, or Cursor) to communicate in a standardized way with external data sources and tools. It transforms your AI from an "isolated chat" into an assistant that can actually execute tasks in your working environment.

The Power of Connection: Clients and Servers

The beauty of MCP lies in its flexibility. A single MCP server can connect to multiple clients. This means you can set up your server once and use it across different platforms.
According to the official documentation, you can install and connect MCP servers to popular clients like:

Claude Desktop & Claude Code: For conversational and command-line interactions
VS Code & Cursor: For seamless integration with your development environment
GitHub Copilot CLI: To extend your coding assistant's capabilities
Zed, Gemini CLI, Goose, and many more: The list keeps growing, demonstrating widespread adoption of the protocol ## How to Configure It: A Quick Look Configuration is usually straightforward and relies on JSON files. For many clients, you just need to specify the command to run your server. For example, to add a filesystem server to a VSCode project, you'd create a .vscode/mcp.json file with content like this:

{
  "servers": {
      "filesystem": {
        "command": "npx",
        "args": [
          "-y",
          "@modelcontextprotocol/server-filesystem",
          "/path/to/your/project"
        ]
      }
  }
}

This file tells VSCode how to start the server. Configuration can be at the project level (to share with your team) or global (for personal use across all your projects).

Your First Server: A Practical Example

Building your own MCP server is more accessible than it might seem. The official TypeScript/JavaScript SDK lets you create a server with custom tools, resources, and prompts.
Here's a simple but complete "Echo Server" example demonstrating the three fundamental concepts:

import { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
import { z } from "zod";

const server = new McpServer({
  name: "Echo",
  version: "1.0.0"
});

// 1. RESOURCE: Provides access to structured data
server.resource(
  "echo",
  new ResourceTemplate("echo://{message}", { list: undefined }),
  async (uri, { message }) => ({
    contents: [{
      uri: uri.href,
      text: `Resource echo: ${message}`
    }]
  })
);

// 2. TOOL: Allows executing actions or functions
server.tool(
  "echo",
  { message: z.string() },
  async ({ message }) => ({
    content: [{ type: "text", text: `Tool echo: ${message}` }]
  })
);

// 3. PROMPT: Reusable instruction templates
server.prompt(
  "echo",
  { message: z.string() },
  ({ message }) => ({
    messages: [{
      role: "user",
      content: {
        type: "text",
        text: `Please process this message: ${message}`
      }
    }]
  })
);

Resources: Like files or data that the client can read
Tools: Functions the AI can execute to perform actions (like querying an API, reading a file, etc.)
Prompts: Message templates that help guide user interactions

A more complex example would be a server connecting to SQLite to run database queries. The querytool below allows the AI to execute SQL and get results in JSON format:

server.tool(
  "query",
  { sql: z.string() },
  async ({ sql }) => {
    const db = getDb();
    try {
      const results = await db.all(sql);
      return {
        content: [{
          type: "text",
          text: JSON.stringify(results, null, 2)
        }]
      };
    } catch (err: unknown) {
      // ... error handling
    }
  }
);

Security and Final Considerations

When implementing an MCP server, security is crucial. This protocol grants AI access to your systems, so best practices are essential:

Principle of Least Privilege: Configure your API keys and access tokens with only the minimum permissions needed. For example, when using a GitHub server, don't grant admin permissions if it only needs to read issues
Local Environment: In development environments, ensure your server isn't exposed to the internet. The connection between client and server is typically local, minimizing risks
Be Careful with Command Execution: If your server allows executing system commands (like a Shell server), the risk is high. Isolate it in a controlled environment or Docker container

Example Repository

RoyserVillanueva / mcp-server

🚀 Mi MCP Server

Un servidor del Model Context Protocol (MCP) construido con TypeScript que se conecta con cualquier cliente MCP como Claude, VS Code, Cursor y más

📋 Tabla de Contenidos

✨ Características

✅ Herramientas (Tools): Funciones que la IA puede ejecutar
✅ Recursos (Resources): Datos estructurados que la IA puede leer
✅ Prompts: Plantillas de instrucciones reutilizables
✅ Compatible con múltiples clientes: VS Code, Claude Desktop, Cursor y más
✅ TypeScript: Código tipado y moderno
✅ Fácil de extender: Añade tus propias herramientas en minutos

🛠️ Herramientas Disponibles

Herramienta	Descripción	Ejemplo
`echo`	Devuelve el mensaje que recibe	`echo("Hola mundo")` → "Echo: Hola mundo"
`sum`	Suma dos números	`sum(5, 3)` → "5

…

View on GitHub

Conclusion

The Model Context Protocol is positioned to become the standard integration layer for AI. It allows you to build assistants that don't just converse, but take action.

Whether you're a developer looking to extend your AI capabilities, or a tech enthusiast curious about the future of AI integration, MCP offers a powerful and accessible way to connect AI with your digital world.