Forem: DAVID JORDAN ANAMPA PANCCA

Exploring Alternative Visualization Tools: Streamlit, Dash, and Bokeh

DAVID JORDAN ANAMPA PANCCA — Fri, 05 Dec 2025 17:26:36 +0000

In recent months, I’ve been experimenting with lightweight tools for building dashboards and interactive visual reports. Instead of relying only on traditional BI platforms, I realized that Python-based frameworks like Streamlit, Dash, and Bokeh offer a faster and more flexible way to create and share data applications.

This article gives a clear explanation of each tool, includes a simple example, and shows how to deploy it to the cloud.

Streamlit

Streamlit is one of the simplest tools for creating data applications. It feels like writing a regular Python script, but the output becomes a functional and interactive web app.

Advantages:

No need for HTML, CSS, or JavaScript
Very fast prototyping
Auto-refresh on save
Works perfectly with data science workflows

Limitation:
Customization is more limited compared to a full web framework.

Dash

Dash, built by Plotly, is more structured and powerful, especially for complex dashboards.

Advantages:

Production-focused
Highly customizable layouts
Interactive visualizations using Plotly
Good for enterprise-grade dashboards

It requires more configuration due to its callback system, but it offers deeper control.

Bokeh

Bokeh is centered around interactive visualizations rendered directly in the browser. It gives you more detailed control over graphical elements.

Advantages:

High interactivity
Can run on a Bokeh Server
Integrates well with NumPy and Pandas
Produces JavaScript-level visualizations without writing JS

Perfect for scientific and research dashboards.

Example: Simple Dashboard Using Streamlit

Below is a straightforward Streamlit example that generates a line chart.

import streamlit as st
import pandas as pd
import numpy as np

st.title("Simple Dashboard Example")

data = pd.DataFrame({
    "values": np.random.randn(50).cumsum()
})

st.line_chart(data)

Run it locally:

pip install streamlit
streamlit run app.py

dashboard will open at:
http://localhost:8501

Deploying to the Cloud

One of the best parts of using Streamlit is how simple it is to deploy a dashboard online.

You can deploy for free using Streamlit Community Cloud.

Steps:

Upload your project to GitHub
Go to: https://streamlit.io/cloud
Click Deploy an app
Select your repository and the app.py file
Deploy

In a few seconds, you will have a public URL to share your app.

Other services you can use for deployment:

Render
Railway
Fly.io
AWS / Azure / Google Cloud

All of them support Python-based web apps.

Conclusion

Tools like Streamlit, Dash, and Bokeh offer powerful alternatives to heavy BI systems. They allow you to create dashboards quickly, write minimal code, and deploy them easily to the cloud.

If you're working on data analytics, machine learning demos, or internal dashboards, these tools are excellent options to explore.

Design Principles of Software: How I Apply Them in Python

DAVID JORDAN ANAMPA PANCCA — Fri, 05 Dec 2025 00:02:54 +0000

When I first started coding, I thought writing software was just about making it work. But soon I realized that making it work is only half the battle—making it clean, flexible, and maintainable is just as important. That’s where software design principles come in.

These principles are like a roadmap for writing code that doesn’t turn into a nightmare as your project grows. In this article, I’ll explain some key principles and show a real example in Python.

Why Design Principles Are Important

Imagine you’ve built a small project, and six months later you come back to fix a bug or add a feature. If your code is messy, you’ll spend more time figuring out what’s happening than actually solving the problem. Good design principles make your code:

Easy to read
Easy to maintain
Flexible for future changes

The most common set of design principles is SOLID:

Single Responsibility Principle (SRP) – Each class or function should have only one job.
Open/Closed Principle (OCP) – Classes should be open for extension but closed for modification.
Liskov Substitution Principle (LSP) – Subclasses should be able to replace parent classes without breaking the program.
Interface Segregation Principle (ISP) – Don’t force classes to implement methods they don’t need.
Dependency Inversion Principle (DIP) – High-level modules should depend on abstractions, not on concrete low-level modules.

A Real Example in Python

To make this concrete, let’s say I’m building a notification system where users can receive alerts via email or SMS. Here’s how I apply the design principles:

from abc import ABC, abstractmethod

# Interface defining what a Notifier should do
class Notifier(ABC):
    @abstractmethod
    def send(self, message: str):
        pass

# SRP: Each notifier has a single responsibility
class EmailNotifier(Notifier):
    def send(self, message: str):
        print(f"Sending email: {message}")

class SMSNotifier(Notifier):
    def send(self, message: str):
        print(f"Sending SMS: {message}")

# OCP & DIP: NotificationService works with any notifier
class NotificationService:
    def __init__(self, notifiers: list[Notifier]):
        self.notifiers = notifiers

    def notify_all(self, message: str):
        for notifier in self.notifiers:
            notifier.send(message)

# Using the system
email = EmailNotifier()
sms = SMSNotifier()
service = NotificationService([email, sms])
service.notify_all("Your order has been shipped!")

How the Principles Are Applied

SRP: Each class has one job (sending email or SMS).
OCP: I can add new notifiers (like WhatsApp) without changing NotificationService.
DIP & ISP: NotificationService depends on the Notifier interface, not specific classes.

This structure keeps the system flexible, easy to extend, and clean, even as it grows.

Conclusion

Applying design principles is not just a recommendation—it is an investment in the quality and longevity of your code. Following SRP, OCP, DIP, and other SOLID principles makes your code easier to understand, safer to modify, and more scalable.

The goal is not just to make your software work today, but to build something that can grow and adapt tomorrow without complications. Adopting these principles from the start ensures cleaner projects, simpler changes, and smoother collaboration.

Observability Practices: Implementing Real-World Monitoring With Python and Prometheus

DAVID JORDAN ANAMPA PANCCA — Thu, 04 Dec 2025 02:19:31 +0000

Modern applications don’t just need to run — they need to be understood. When something goes wrong in production, teams must be able to detect issues, diagnose the root cause, and monitor the system’s behavior in real time.
This is where observability becomes essential.

In this article, I explain what observability is, why it matters, and how I implemented a real-world example using Python, Prometheus, and FastAPI. You can use this code to build your own monitoring pipeline.

What Is Observability?

Observability is the ability to understand the internal state of a system based on the data it produces.

It is built around three core pillars:

1. Metrics

Numeric values that reflect system state.
Examples: request latency, CPU usage, memory consumption.

2. Logs

Detailed event records generated by applications and systems.
Examples: authentication messages, errors, warnings.

3. Traces

End-to-end tracking of requests across services.
Useful in microservices and distributed systems.

Together, these help answer:

What is happening?
Why is it happening?
Where is it failing?

Why Observability Matters

Observability helps teams:
Detect issues earlier
Reduce downtime
Improve performance
Understand user impact
Monitor applications at scale
Make data-driven decisions

Without observability, debugging becomes slow, reactive, and inconsistent.

Real-World Example: Observability With Python + Prometheus

For this example, I implemented observability on a small API using:

Python
FastAPI
Prometheus (metrics collection)
Grafana (optional dashboards)

This setup is commonly used in startups and cloud-native environments.

1. Install Dependencies

First, install the required packages:

pip install fastapi uvicorn prometheus-client

2. Python API With Prometheus Metrics

Below is a simple FastAPI application that exposes metrics at /metrics.
Prometheus will scrape this endpoint every few seconds.

__from fastapi import FastAPI
from prometheus_client import Counter, Histogram, generate_latest
from fastapi.responses import Response
import time
import random

app = FastAPI()

REQUEST_COUNT = Counter("api_requests_total", "Total number of API requests received")
REQUEST_LATENCY = Histogram("api_request_latency_seconds", "API request latency")

@app.get("/")
def home():
REQUEST_COUNT.inc()
with REQUEST_LATENCY.time():
time.sleep(random.uniform(0.1, 0.5))
return {"message": "API is running successfully"}_

@app.get("/metrics")
def metrics():
return Response(generate_latest(), media_type="text/plain")_

What this code does:
Metric Description
api_requests_total Counts all incoming requests
api_request_latency_seconds Measures request duration

These metrics help determine whether the API is fast, overloaded, or failing.

3. Prometheus Configuration

Create a file named prometheus.yml:

_global:
scrape_interval: 5s

scrape_configs:

job_name: "python-api" static_configs:
- targets: ["localhost:8000"]_

Prometheus will scrape the metrics endpoint at:

http://localhost:8000/metrics

4. Run Prometheus

Download Prometheus, then run it:

./prometheus --config.file=prometheus.yml

Open the Prometheus UI at:
_
http://localhost:9090_

Query metrics like:

api_requests_total
rate(api_requests_total[1m])
api_request_latency_seconds_bucket

5. Optional: Grafana Dashboard

Grafana can visualize your Prometheus metrics with modern dashboards.

Typical graphs include:

Request rate
CPU and memory usage
Error percentage
Latency (p95, p99)

This is valuable when demonstrating observability to teams or stakeholders.

Observability Best Practices

To implement observability professionally:

✔ Instrument every major endpoint

Expose metrics for performance-critical APIs.

✔ Standardize metric names

Avoid random or unstructured naming.

✔ Include labels (tags)

Labels such as status_code, endpoint, or method add context.

✔ Use alerts

For example:
“95th percentile latency exceeds 500ms for 3 minutes.”

✔ Visualize everything

Dashboards make patterns obvious.

✔ Combine logs, metrics, and traces

Observability works best when all three pillars are present.

Conclusion

Observability allows teams to deeply understand how their systems behave.
Using Prometheus + FastAPI, I demonstrated how to expose useful metrics that support:

Faster debugging
Better performance insights
Safer deployments
Scalable system monitoring

This example can be expanded with tracing (OpenTelemetry), log pipelines (ELK Stack), or full cloud observability platforms like AWS CloudWatch, Datadog, or Azure Monitor.

References

Prometheus Documentation – https://prometheus.io/docs
Grafana Documentation – https://grafana.com/docs
FastAPI – https://fastapi.tiangolo.com
OpenTelemetry – https://opentelemetry.io

Building a Remote MCP Server and Connecting It to Any MCP Client

DAVID JORDAN ANAMPA PANCCA — Thu, 04 Dec 2025 02:01:52 +0000

Introduction

The Model Context Protocol (MCP) is a new standard that allows AI models—such as Claude, ChatGPT, or Gemini—to connect with external tools, APIs, and systems in a secure and controlled way. Instead of being limited to conversation, the AI can interact with real-world environments and perform useful actions.

In this article, I explain how to build a simple MCP Server, how it works internally, how to connect it to any MCP Client, and why this technology is becoming essential for developers and small teams who want to integrate AI into their workflows.

What Is an MCP Server?

An MCP Server is a small application that exposes tools, functions, or resources to an AI model through the MCP protocol.
It works like a bridge:

AI Model → MCP Client → Your MCP Server → Tools / APIs / Files / Databases

An MCP Server can provide:

File access (read/write)

API calls

Automation scripts

Database query tools

Cloud integrations

Custom business logic

Any MCP-compatible client can communicate with it, including:

Claude Desktop

MCP plugins for VSCode

Custom MCP Clients

How MCP Architecture Works

The general architecture looks like this:

AI Model → MCP Client → WebSocket/STDIO → MCP Server → Your Tools

The key idea:

The client handles the communication

The server exposes the tools

The AI model decides when to use them

This separation keeps everything secure and modular.

Why Build Your Own MCP Server?

Building an MCP Server lets your AI assistant interact directly with your environment.

Benefits:

Automate repetitive tasks

Trigger scripts or system actions

Query databases

Access real-time information

Build personalized developer tools

Create AI-powered copilots for your workspace

It transforms the AI into a hands-on assistant, not just a chatbot.

Building a Simple MCP Server (Step-by-Step)

Here is the simplest structure for an MCP Server using Node.js.

Step 1 — Create a new project
npm init -y
npm install @modelcontextprotocol/sdk typescript ts-node
npx tsc --init

Step 2 — Create the server file

src/server.ts

import {
Server,
Tool,
StdioServerTransport,
} from "@modelcontextprotocol/sdk";

const server = new Server(
{
name: "example-mcp-server",
version: "1.0.0",
},
{
capabilities: { tools: {} },
}
);

server.tool("getDate", new Tool(async () => {
return { now: new Date().toISOString() };
}));

server.connect(new StdioServerTransport());

Step 3 — Build and run
npm run build
node dist/server.js

Connecting the Server to Claude Desktop

Edit the Claude config file:

Windows:
%APPDATA%/Claude/claude_desktop_config.json

Mac:
~/Library/Application Support/Claude/claude_desktop_config.json

Add:

{
"mcpServers": {
"myServer": {
"command": "node",
"args": ["path/to/dist/server.js"]
}
}
}

Restart Claude — the tool will appear automatically.

Optional: Deploying to the Cloud

You can deploy your MCP Server to:

Google Cloud Run

Cloudflare Workers

Vercel Edge Functions

Any container-based system

This allows AI tools to access your server remotely and securely.

Example Use Cases ✔ Developer automation

Let Claude run scripts, lint code, or review PRs using local tools.

✔ Internal business tools

Let AI access internal APIs, inventory systems, or customer data (safely).

✔ File automation

Automatically generate documents, update logs, and manage repositories.

✔ Cloud operations

Interact with cloud services via API integrations.

Good Practices

Do not expose tools without authentication

Log all interactions for auditing

Validate all input schemas

Apply rate limiting

Keep the server’s environment isolated

These prevent unsafe use and keep the MCP server secure.

Conclusion

Building an MCP Server is a powerful way to connect AI models with real-world systems. With only a few lines of code, you can expose tools, automate workflows, and create intelligent assistants that work directly with your environment. Whether you deploy it locally or in the cloud, MCP opens the door to the next generation of AI-powered automation.

References

Cloudflare Agents Docs (2024). Build a Remote MCP Server.

Google Cloud Blog (2024). Deploy a Remote MCP Server to Cloud Run.

Composio (2024). MCP Server: Step-by-Step Guide to Building from Scratch.

Anthropic (2024). Model Context Protocol Specification.