DEV Community: FABIOLA ESTEFANI POMA MACHICADO

Creating a Custom MCP Server with Flask to Power AI Code Execution

FABIOLA ESTEFANI POMA MACHICADO — Sat, 05 Jul 2025 19:36:28 +0000

🚀 Understanding MCP (Machine Control Protocol)
MCP is a lightweight protocol that allows applications like Claude, VSCode, or ChatGPT to interact with code execution environments. Through a simple HTTP interface, these clients can send code, have it executed remotely, and receive the result — making automation and dynamic code evaluation much more flexible.

In this guide, you’ll learn how to build a minimal MCP-compliant server using Flask in Python, deploy it on Render, and connect it with any compatible tool.

🧰 Technologies Used

Lightweight web server: Python + Flask
Cloud hosting for deployment: Render.com

Open repository for source code: GitHub

🛠 Step 1: Build the MCP Server Using Python
a. Set Up Your Environment

mkdir flask-mcp-server
cd flask-mcp-server
python3 -m venv env
source env/bin/activate
pip install flask

b. Create app.py

from flask import Flask, request, jsonify

app = Flask(__name__)

@app.route('/mcp', methods=['POST'])
def handle_mcp():
    data = request.get_json()
    code = data.get("code")
    language = data.get("language")

    if language == "python":
        try:
            local_vars = {}
            exec(code, {}, local_vars)
            return jsonify({"output": local_vars})
        except Exception as e:
            return jsonify({"error": str(e)})
    return jsonify({"error": "Unsupported language"}), 400

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=5000)

☁️ Step 2: Deploying to Render.com
Push your code to GitHub.

Create a new Web Service with these options:

Build command: pip install -r requirements.txt

Start command: python app.py

Render will generate a URL like:
https://flask-mcp.onrender.com/mcp

🤖 Step 3: Test with an MCP-Compatible Client
Once your server is live, try sending Python code from Claude or a tool like Postman.

Sample Claude Prompt:

Use this MCP endpoint: https://flask-mcp.onrender.com/mcp
Send this Python code:
print("Hello MCP from Claude")

📁 GitHub:
https://github.com/fabipm/mcp-flask-server

Included:

app.py Flask backend
Instructions for deploying to Render
Sample payload for testing

Observability Practices in Modern Software Systems

FABIOLA ESTEFANI POMA MACHICADO — Sat, 05 Jul 2025 04:59:23 +0000

🌐What is Observability?
Observability is the ability to infer the internal state of a system by examining its outputs—primarily through logs, metrics, and traces. It extends traditional monitoring by allowing dynamic querying and root cause analysis of system behavior.
📈 Why Observability Matters
In modern microservices and distributed systems, traditional monitoring is no longer enough. Observability helps by:

Detecting anomalies proactively
Reducing Mean Time To Detect (MTTD) and Mean Time To Resolve (MTTR)
Supporting real-time diagnostics
Enabling end-to-end visibility across components

🔧 Real-World Example: Observability with Prometheus and Grafana in Node.js
We'll monitor a simple Node.js API and visualize request metrics on Grafana.
🛠️ Setup Overview

Language: Node.js (Express)
Metric Collector: Prometheus
Visualization: Grafana
Exporter: prom-client (Node.js metrics exporter) 📦 Install Dependencies

npm init -y
npm install express prom-client

🧪 Sample Application (server.js)

const express = require('express');
const client = require('prom-client');

const app = express();
const collectDefaultMetrics = client.collectDefaultMetrics;
collectDefaultMetrics();

const httpRequestDurationMicroseconds = new client.Histogram({
  name: 'http_request_duration_seconds',
  help: 'Duration of HTTP requests in ms',
  labelNames: ['method', 'route', 'code'],
  buckets: [0.1, 0.3, 0.5, 1, 1.5]
});

app.use((req, res, next) => {
  const end = httpRequestDurationMicroseconds.startTimer();
  res.on('finish', () => {
    end({ method: req.method, route: req.route?.path || req.url, code: res.statusCode });
  });
  next();
});

app.get('/', (req, res) => {
  res.send('Hello, world!');
});

app.get('/metrics', async (req, res) => {
  res.set('Content-Type', client.register.contentType);
  res.end(await client.register.metrics());
});

app.listen(3000, () => {
  console.log('Server running on http://localhost:3000');
});

📡 Prometheus Configuration (prometheus.yml)

global:
  scrape_interval: 10s

scrape_configs:
  - job_name: 'node_app'
    static_configs:
      - targets: ['localhost:3000']

📊 Visualizing Metrics with Grafana

Add Prometheus as a data source in Grafana
Create a dashboard with a panel using this query:

rate(http_request_duration_seconds_count[1m])

You can visualize per-route traffic, latency buckets, or status code breakdown.

🎯 Best Practices for Observability

Expose /metrics endpoints for all services
Use structured logging with correlation IDs
Label metrics with meaningful tags (method, route, status)
Automate dashboards for services and infrastructure
Set alerts based on SLOs/SLAs

🧩 Wrapping Up
Observability isn't just about tools—it's a mindset. By embracing metrics, logs, and traces from the ground up, you build software that is easier to debug, scale, and maintain.
If you’d like, I could also show you how to push logs to the ELK stack or wire traces using OpenTelemetry in a similar setup. Want to take it a step further with something like MCP integration or Power BI for correlating metrics to thesis outcomes? I’m all ears.

📊 Dash: A Powerful Tool for Building Dashboards and Reports

FABIOLA ESTEFANI POMA MACHICADO — Tue, 29 Apr 2025 05:02:24 +0000

Dash is a powerful Python framework developed by Plotly that allows users to create interactive dashboards and reports with minimal effort. It is especially popular among data scientists and analysts who want to create web-based visualizations without learning web development.

🚀 What is Dash?
Dash is an open-source Python library that helps build analytical web applications. It combines:

Flask as the web server,
Plotly.js for powerful, interactive graphics,
React.js for dynamic and flexible user interfaces.

Thanks to this, Dash apps are responsive, customizable, and can handle complex visualizations.

✨ Main Features

Pure Python Development: No need for HTML, CSS, or JavaScript knowledge.
Interactive Visualizations: Easily create dynamic graphs.
Simple Layout Design: Organize dashboards with easy-to-use components.
Integration Friendly: Works well with Pandas, NumPy, and other data tools.
Deployment Ready: Apps can be deployed easily on services like Render or Heroku.

🛠️ Example: A Simple Sales Dashboard
Here's an example of a Dash app that visualizes sales data over time:

import dash
from dash import dcc, html
import plotly.express as px
import pandas as pd

# Create a Dash application
app = dash.Dash(__name__)

# Example data
data = {
    "Fecha": ["2023-01-01", "2023-01-02", "2023-01-03", "2023-01-04", "2023-01-05"],
    "Ventas": [100, 400, 300, 500, 450],
    "Categoría": ["Electrónica", "Electrónica", "Ropa", "Ropa", "Electrónica"]
}
df = pd.DataFrame(data)
df["Fecha"] = pd.to_datetime(df["Fecha"])

# Create an interactive graph
fig = px.line(df, x="Fecha", y="Ventas", color="Categoría", title="Ventas por Categoría")

# Define the app layout
app.layout = html.Div([
    html.H1("Sales Dashboard"),
    dcc.Graph(figure=fig)
])

# Expose the server (important for deployment)
server = app.server

# Run the app locally
if __name__ == "__main__":
    app.run_server(host="0.0.0.0", port=8080, debug=True)

Explanation:

dcc.Graph is used to embed the Plotly chart.
html.H1 and html.Div structure the page.
plotly.express generates the line chart based on the sales data.
server = app.server allows deployment on cloud platforms like Render.

Conclusion
Dash makes it easy for Python developers to create beautiful, interactive dashboards and professional reports. Whether you're building a simple app or a complex business intelligence tool, Dash provides all the flexibility and performance you need.

If you want to turn your data into powerful web applications, Dash is definitely a tool you should explore!

The source code and the automated deployment workflow for Render can be found here: https://github.com/fabipm/Research01_885_U1.git

Enterprise Design Pattern: Transaction Script

FABIOLA ESTEFANI POMA MACHICADO — Mon, 28 Apr 2025 00:07:24 +0000

Introduction
In enterprise applications, organizing business logic clearly and simply is key to creating maintainable systems.
One classic pattern for this is the Transaction Script.
It structures business logic as a series of procedural scripts, where each script handles a specific transaction or request.

Transaction Script is ideal for simple or small systems where the domain logic is not complex.

Real-world Analogy
Imagine a cashier at a grocery store.
Each customer transaction — scanning items, applying discounts, processing payment — is handled step-by-step without involving complex objects or workflows.

Similarly, in Transaction Script, we handle each business task step-by-step through a function or procedure.

Real-World Example in Code
Let's build a simple banking system where users can deposit and withdraw money.

We’ll use Python because it's simple to read and write.

# transaction_script.py

# A simple in-memory 'database' of accounts
accounts = {
    'alice': 1000,
    'bob': 500
}

def deposit(account_name, amount):
    if account_name not in accounts:
        raise ValueError("Account not found.")
    if amount <= 0:
        raise ValueError("Amount must be positive.")
    accounts[account_name] += amount
    print(f"Deposited {amount} to {account_name}. New balance: {accounts[account_name]}")

def withdraw(account_name, amount):
    if account_name not in accounts:
        raise ValueError("Account not found.")
    if amount <= 0:
        raise ValueError("Amount must be positive.")
    if accounts[account_name] < amount:
        raise ValueError("Insufficient funds.")
    accounts[account_name] -= amount
    print(f"Withdrew {amount} from {account_name}. New balance: {accounts[account_name]}")

def main():
    deposit('alice', 200)
    withdraw('bob', 100)

if __name__ == "__main__":
    main()

Explanation
Each function (deposit, withdraw) is a transaction script that:

Validates input

Updates the "database" (dictionary accounts)

Prints the result

There's no need for complex classes or objects.
Each business operation is directly coded as a simple procedure.

Conclusion
Transaction Script is a great pattern when:

You have straightforward logic.
You want fast, simple development.
The system is small or not very complicated.

For bigger or more complex applications, you might eventually move to a more structured approach like Domain Model.

You can find the full code for this article in my GitHub repository: https://github.com/fabipm/Research02_SI889_U1_Poma.git

Design Principles of Software

FABIOLA ESTEFANI POMA MACHICADO — Fri, 25 Apr 2025 00:13:40 +0000

Introduction
Software design is a crucial discipline in the development of robust applications and systems. There are various principles that guide how to structure the code effectively to ensure quality, maintainability, and scalability. These principles not only ensure the software functions correctly but also facilitate its evolution over time.

In this article, we will explore some of the most well-known and widely applied software design principles, with a real-world example in Python.

Common Software Design Principles

Single Responsibility Principle (SRP):
This principle states that a class or module should have only one reason to change. In other words, each component should be responsible for only one functionality.
Open/Closed Principle (OCP):
A software entity (class, module, function) should be open for extension but closed for modification. This allows you to add new features without altering existing code.
Liskov Substitution Principle (LSP):
Derived classes should be able to substitute their base classes without affecting the correctness of the program.
Interface Segregation Principle (ISP):
Clients should not be forced to depend on interfaces they do not use. This encourages the creation of smaller, more focused interfaces.
Dependency Inversion Principle (DIP):
High-level modules should not depend on low-level modules. Both should depend on abstractions. Abstractions should not depend on details. Details should depend on abstractions.

Real-World Analogy
Imagine a car manufacturing company that designs different car models. Each model has specific components, such as engines, wheels, and transmissions. The company applies design principles to ensure that these components can be easily modified or replaced without disrupting the entire manufacturing process. For example, if a new type of engine is introduced, the car models should be able to adapt without significant changes to the overall structure.

Similarly, in software design, applying these principles helps ensure that the system remains flexible and maintainable, even as requirements change or new features are added.

Real-World Example in Code
Let’s look at a simple example in Python where we apply some of these principles. Imagine we’re developing a simple system for processing bank transactions. Initially, we might start with a simple, monolithic function. As we grow the system, we apply design principles to improve its structure.

account.py

class Account:
    def __init__(self, owner, balance):
        self.owner = owner
        self.balance = balance

    def deposit(self, amount):
        if amount <= 0:
            raise ValueError("Deposit amount must be positive.")
        self.balance += amount

    def withdraw(self, amount):
        if amount <= 0:
            raise ValueError("Withdrawal amount must be positive.")
        if self.balance < amount:
            raise ValueError("Insufficient funds.")
        self.balance -= amount

transaction_processor.py

from account import Account  
class TransactionProcessor:
    def __init__(self, account):
        self.account = account

    def process_transaction(self, transaction_type, amount):
        if transaction_type == "deposit":
            self.account.deposit(amount)
        elif transaction_type == "withdraw":
            self.account.withdraw(amount)
        else:
            raise ValueError("Invalid transaction type.")
        print(f"Transaction successful! New balance: {self.account.balance}")

# Example of usage
account = Account("Alice", 1000)
transaction_processor = TransactionProcessor(account)

transaction_processor.process_transaction("deposit", 200)
transaction_processor.process_transaction("withdraw", 100)

Explanation

We have a Account class that handles account-related operations like deposit and withdraw.

We separate the responsibility of processing transactions into a TransactionProcessor class. This helps adhere to the Single Responsibility Principle (SRP) because each class has one distinct responsibility.

The Open/Closed Principle (OCP) is adhered to, as we can easily add new transaction types without modifying the existing classes.

The Liskov Substitution Principle (LSP) is also respected, as we could replace or extend the Account class with subclasses (e.g., SavingsAccount) without breaking the functionality.

Conclusion
Software design principles help ensure that code is not only functional but also maintainable and scalable. Applying principles like SRP, OCP, LSP, ISP, and DIP enables developers to write code that can easily adapt to new requirements and changes. As systems grow more complex, these principles become essential to managing the complexity and ensuring that the software remains flexible and easy to maintain.

You can find the full code for this article in my GitHub repository: https://github.com/fabipm/Research01_SI889_U1_Poma

Testing Management Tools

FABIOLA ESTEFANI POMA MACHICADO — Wed, 11 Dec 2024 19:51:47 +0000

Test management tools help software developers automate and manage testing. These tools are important to verify that the software is working correctly. For example:

1. GitHub Actions
GitHub Actions is built into GitHub. It lets you automate tests directly in your project repository. You can write workflows in YAML files to run tests.

Example:

name: Run Tests
on:
  push:
    branches:
      - main
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - name: Run Tests
        run: npm test

Pros:

Easy to integrate if you use GitHub.
Free for public repositories.

Cons:
Limited free minutes for private repositories.

2. Jenkins
Jenkins is an open-source tool. It supports many plugins to help automate testing and deployment.

Example:

1) Install Jenkins on your server.
2) Create a pipeline to test your code.
3) Use a Jenkinsfile to define steps.

pipeline {
    agent any
    stages {
        stage('Test') {
            steps {
                sh 'npm test'
            }
        }
    }
}

Pros:

Very flexible.
Works with almost any tool.

Cons:
Needs more setup.
Requires a server.

3. GitLab CI/CD
GitLab CI/CD is part of GitLab. It helps to run tests and deploy applications. Like GitHub Actions, it uses YAML files.

test:
  stage: test
  script:
    - npm test

Pros:
Integrated with GitLab.
Free tier includes many features.

Cons:
Can be complex for beginners.

Conclusion
Testing management tools like GitHub Actions, Jenkins, and GitLab CI/CD make it easier to automate and improve the testing process. Each tool has unique features: GitHub Actions is simple for GitHub users, Jenkins is flexible for advanced setups, and GitLab CI/CD is great for GitLab projects.

API Testing with Katalon Studio

FABIOLA ESTEFANI POMA MACHICADO — Thu, 21 Nov 2024 18:17:26 +0000

What is Katalon Studio?
Katalon Studio is an easy-to-use automation tool for testing APIs, web, and mobile applications. It helps both beginners and experts perform tests quickly.

Setting Up API Test in Katalon Studio

Download and Install Katalon Studio: Get it from Katalon.
Create a New Project: Open Katalon, create a new API project.

Example 1: Simple GET Request

Create a Test Case: Right-click on Test Cases > New Test Case and name it "GetPostsTest".
Add GET Request: URL: https://jsonplaceholder.typicode.com/posts.
Verify Response:

import com.kms.katalon.core.webservice.keyword.WSBuiltInKeywords as WS

def response = WS.sendRequest(findTestObject('API Requests/GetPostsRequest'))
WS.verifyResponseStatusCode(response, 200)
WS.verifyElementPropertyValue(response, 'title', 'sunt aut facere repellat')

This tests if the API returns status 200 and checks the title property.

Example 2: Simple POST Request

Create a POST Request: URL: https://jsonplaceholder.typicode.com/posts. Body:

{
  "title": "foo",
  "body": "bar",
  "userId": 1
}

Send and Validate:

def response = WS.sendRequest(findTestObject('API Requests/PostCreateRequest'))
WS.verifyResponseStatusCode(response, 201)
WS.verifyElementPropertyValue(response, 'title', 'foo')

Conclusion
Katalon Studio simplifies API testing by providing an intuitive interface. With just a few steps, you can automate API requests, validate responses, and ensure your application integrates properly.

Using Veracode to Improve Your Application

FABIOLA ESTEFANI POMA MACHICADO — Fri, 04 Oct 2024 00:31:52 +0000

In software development, it is important to keep your code safe and of high quality. Veracode is a tool that helps you check your code for problems early, before it is deployed. This type of tool is called SAST (Static Application Security Testing). Let’s see how Veracode can be used in any application.

What is Veracode?
Veracode is a cloud-based tool that checks your code for security problems. It helps developers find vulnerabilities, like injection flaws or broken authentication, and suggests how to fix them. Veracode works with many programming languages and frameworks.

Why Use Veracode?
Detect Issues Early: Veracode checks your code early in development, saving time and reducing the chance of big problems later.
Detailed Reports: After scanning, Veracode gives a clear report that shows what needs to be fixed and how serious the problem is.
Integration: Veracode can be connected to your CI/CD pipeline, meaning it checks code every time there’s a new update or version.

How to Use Veracode
Set Up: Install Veracode in your development environment, like Eclipse or Visual Studio.
Scan Your Code: Upload your code to Veracode. It will check it and create a report with all the issues found.
Fix Problems: Use Veracode’s suggestions to fix any problems. You can resubmit the code for a new scan after fixing it.
Continuous Scanning: Make Veracode part of your process. Keep scanning new code to catch issues before they become big problems.

Benefits of Veracode
Early Detection: Find and fix vulnerabilities early.
Improves Code Quality: Veracode not only checks for security but also helps improve overall code quality.
Easy to Use: It integrates with your existing tools and provides easy-to-understand reports.

Conclusion
Veracode is a powerful tool for developers to keep their applications secure and high-quality. By using Veracode in your workflow, you can easily find and fix code problems early, which helps you create better and safer software.

Using the Data Mapper Pattern in a Simple Customer Management System

FABIOLA ESTEFANI POMA MACHICADO — Sat, 21 Sep 2024 06:08:16 +0000

In big applications, it's important to keep the business logic (how the app works) separate from the data logic (how the app talks to the database). One way to do this is by using the Data Mapper Pattern. This pattern helps transfer data between the app’s objects and the database without making them depend on each other.

Example: Customer Management System
Let's say we are building a system to manage customers, where we need to store and retrieve customer information from a MySQL database.

Customer Class (Domain) This class holds the customer’s information and business logic.

public class Customer {
    private int id;
    private String name;
    private String email;
    // Getters and setters
}

CustomerMapper Interface This defines methods to interact with the database.

public interface CustomerMapper {
    Customer findById(int id);
    void insert(Customer customer);
    void update(Customer customer);
    void delete(int id);
}

CustomerMapperImpl Class This class uses JDBC to handle the actual database operations.

import java.sql.*;

public class CustomerMapperImpl implements CustomerMapper {
    private Connection connection;

    public CustomerMapperImpl(Connection connection) {
        this.connection = connection;
    }

    @Override
    public Customer findById(int id) {
        // Code to get a customer from the database
    }

    @Override
    public void insert(Customer customer) {
        // Code to add a customer to the database
    }

    @Override
    public void update(Customer customer) {
        // Code to update a customer in the database
    }

    @Override
    public void delete(int id) {
        // Code to delete a customer from the database
    }
}

Benefits

Separation of Concerns: The app's business logic is separate from database logic.
Flexibility: You can change the database without changing the business logic code.

Deploying a Node.js Application on AWS Elastic Beastalk

FABIOLA ESTEFANI POMA MACHICADO — Thu, 04 Jul 2024 22:41:48 +0000

Deploying applications to AWS Elastic Beanstalk is straightforward and ideal for quickly deploying Node.js applications without managing infrastructure.
We'll deploy a basic Node.js application using Express.js to AWS Elastic Beanstalk.

Example Application

Setup Your Project

mkdir nodejs-app
cd nodejs-app
npm init -y

Install Dependencies

npm install express

Create The Application

const express = require('express');
const app = express();

app.get('/', (req, res) => {
  res.send('Welcome to AWS Elastic Beanstalk Deployment!');
});

const port = process.env.PORT || 3000;
app.listen(port, () => {
  console.log(`Server running on port ${port}`);
});

Create .ebextensions Directory

option_settings:
  aws:elasticbeanstalk:container:nodejs:
    NodeCommand: "app.js"

Deploy to AWS Elastic Beanstalk

Sign in to AWS Management Console and navigate to Elastic Beanstalk.
Create a new application and environment, selecting Node.js platform.
Upload your application code (including app.js, package.json, and node_modules if necessary).
Deploy your application.

Access Your Application
Once deployed, Elastic Beanstalk will provide you with a URL to access your application (http://app-name.elasticbeanstalk.com).

Understanding API Architecture Styles Using SOAP

FABIOLA ESTEFANI POMA MACHICADO — Wed, 12 Jun 2024 00:06:58 +0000

What is SOAP?
SOAP stands for Simple Object Access Protocol. It is a protocol used for exchanging information in the implementation of web services. SOAP relies on XML (Extensible Markup Language) to format messages and usually relies on other application layer protocols, most notably HTTP and SMTP, for message negotiation and transmission.

Key Features of SOAP

Protocol-based: SOAP is a protocol, which means it has strict rules for messaging.
Language and Platform Independent: SOAP can be used on any platform and with any programming language.
Standardized: SOAP has a standardized set of rules, making it a reliable choice for communication between different systems.

Example of a Simple SOAP Request
Imagine you want to create a web service that provides weather information. A SOAP request to get the weather for a specific city might look like this:

<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:web="http://www.example.com/weather">
   <soapenv:Header/>
   <soapenv:Body>
      <web:GetWeather>
         <web:CityName>New York</web:CityName>
      </web:GetWeather>
   </soapenv:Body>
</soapenv:Envelope>

In this XML, we have an Envelope, which is the top element in a SOAP message. Inside it, there is a Header (which is empty in this case) and a Body which contains the actual request. The GetWeather request asks for the weather in New York City.

Example of a Simple SOAP Response
The server might respond with the following SOAP message:

<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/">
   <soapenv:Header/>
   <soapenv:Body>
      <web:GetWeatherResponse>
         <web:CityName>New York</web:CityName>
         <web:Temperature>25</web:Temperature>
         <web:Condition>Sunny</web:Condition>
      </web:GetWeatherResponse>
   </soapenv:Body>
</soapenv:Envelope>

Here, the Envelope and Body are similar to the request. The GetWeatherResponse contains the weather information: the city name, temperature, and condition.

Conclusion
SOAP is a protocol used to exchange structured information in the implementation of web services. It is protocol-based, language, and platform independent, and standardized. By using XML for its messages, it ensures a high level of compatibility across different systems and platforms.