AI on Thomas

MCP pour les nuls - la suite

Tue, 21 Apr 2026 00:00:00 +0000

Suite du post précédent, je mets en place une gateway pour protéger mon serveur MCP. Le serveur MCP a été déployé sur Azure Container, il est accessible.

Mise en place d’une Flex gateway

Création et enregistrement de ma nouvelle Flex gateway (mcp-gateway)

J’ai créé une image Docker de la flex avec son fichier d’enregistrement. L’image Docker tourne sur un Azure Container, elle est maintenant visible sur Anypoint (le control plane de MuleSoft).

Configuration de mon server MCP sur Anypoint

Documentation officielle de MuleSoft
Ajout de mon serveur MCP (mcp_card)

Aller sur API Manager (Anypoint) et sélectionner Agent and Tools Instances.

En sélectionnant la Flex Gateway mise en place pour ce projet.

Maintenant on peut ajouter un MCP Server et on finalise la configuration.

Le contrat du serveur mcp_card est visible sur le portail API d’Anypoint (Exchange).

Le serveur mcp_card est théoriquement accessible via la gateway, il faut maintenant ajouter les policies pour le sécuriser.

Policies pour mon serveur MCP

MCP Support

Cette policy est obligatoire pour le bon fonctionnement du serveur MCP.

Client ID Enforcement

Pour limiter l’accès au serveur mcp_card aux applications enregistrées qui ont le duo client_id/client_secret dans leurs Headers.

Nous avons donc 2 policies configurées sur notre gateway pour le serveur mcp_card.

Appels du serveur MCP avec Bruno

Nous allons tester la connectivité au server mcp_card avec le client API Bruno.

Configuration des Headers

Appels aux services du serveur mcp_card

Si le client_secret est faux dans les Headers

Observabilité

L’outil de monitoring d’Anypoint nous permet au niveau de la configuration du serveur de visualiser les appels. On voit les appels de chaque service et les appels en erreurs.

card_details

transaction_list

MCP pour les nuls

Tue, 24 Mar 2026 00:00:00 +0000

MCP Kesako ?

Protocole de communication entre un agent IA et un service.

MCP Documentation

Le service permet à un agent d’avoir accès à des données structurées (format JSON) qui ne sont pas déjà présentes dans son modèle LLM. Il existe deux protocoles de communication, io et http. Dans mon cas, je souhaite utiliser http, dans l’idée de créer un serveur MCP accessible à tous.

Pour accélérer le développement, je vais utiliser la librairie Python fastMCP :

fastMCP: https://gofastmcp.com/getting-started/welcome

Prototype du service MCP

Mon cas d’utilisation : je veux mettre en place un service qui donne les détails d’une carte de crédit si on lui donne le numéro en paramètre, ou la liste des transactions d’un compte.

Dans ce premier post, je ne vais pas aborder la sécurité ni l’observabilité, mais je souhaite en parler bientôt dans un post dédié, notamment via une API Gateway.

Pour commencer

Dans un environnement Python :

pip install fastmcp

Serveur MCP Card Details

J’ai créé deux services : le détail d’une carte et la liste des transactions d’un compte, avec des données fictives.

from fastmcp import FastMCP
from starlette.requests import Request
from starlette.responses import PlainTextResponse

mcp = FastMCP("My MCP Server")

@mcp.custom_route("/health", methods=["GET"])
async def health_check(request: Request) -> PlainTextResponse:
    return PlainTextResponse("OK")

@mcp.tool
def card_details(card_number: str) -> dict:
    # Dummy implementation for demonstration purposes
    return {
        "card_number": card_number,
        "card_type": "Visa",
        "expiry_date": "12/25",
        "cardholder_name": "John Doe"
    }

@mcp.tool
def transaction_list(account_id: str) -> list:
    # Dummy implementation for demonstration purposes
    return [
        {"transaction_id": "txn_001", "amount": 100.0, "currency": "USD", "status": "completed"},
        {"transaction_id": "txn_002", "amount": 50.0, "currency": "USD", "status": "pending"},
        {"transaction_id": "txn_003", "amount": 75.0, "currency": "USD", "status": "failed"}
    ]

if __name__ == "__main__":
    mcp.run(transport="http", port=8000)

Pour lancer le serveur qui va écouter sur le port 8000, j’exécute :

python my_server.py

Configuration de Copilot

Une fois que le serveur MCP tourne dans la console, je configure mon GitHub Copilot pour qu’il ajoute le serveur dans sa liste :

Une fois la configuration faite, on peut voir le serveur et les deux fonctionnalités (card_details et transaction_list) :

Utilisation du service

Les deux fonctionnalités sont maintenant accessibles dans le chat de Copilot :

Prochaines étapes

Mettre en place une API Gateway
- Authentification
- Observabilité
- Limitation, quotas

MLOps: Bridging Machine Learning and Operations

Fri, 13 Feb 2026 00:00:00 +0000

What is MLOps?

MLOps (Machine Learning Operations) is a set of practices that combines machine learning, DevOps, and data engineering to streamline the development, deployment, and maintenance of machine learning systems in production.

Think of it as applying software engineering best practices to machine learning workflows—but with additional complexity due to data, model versioning, and continuous retraining requirements.

The MLOps Landscape

Core Pillars

┌─────────────────────────────────────────┐
│          ML Model Development           │
│  (Experimentation, Training, Tuning)    │
└────────────────┬────────────────────────┘
                 │
┌────────────────┴────────────────────────┐
│     Model Validation & Testing          │
│  (Metrics, A/B Testing, Performance)    │
└────────────────┬────────────────────────┘
                 │
┌────────────────┴────────────────────────┐
│      Model Deployment & Serving         │
│  (Containerization, APIs, Scaling)      │
└────────────────┬────────────────────────┘
                 │
┌────────────────┴────────────────────────┐
│   Monitoring, Retraining & Governance   │
│  (Data Drift, Performance, Compliance)  │
└─────────────────────────────────────────┘

Key Components

1. Data Management

Data Pipeline: Automated extraction, transformation, and loading (ETL)
Data Versioning: Track datasets like code (DVC, Delta Lake)
Data Quality: Validation, schema enforcement, anomaly detection
Feature Store: Centralized feature management and serving

2. Model Development

Experimentation Tracking: Log hyperparameters, metrics, artifacts (MLflow, Weights & Biases)
Model Registry: Version control for trained models
Reproducibility: Environment specifications, random seeds, documentation
Collaboration: Shared resources for data scientists and engineers

3. Model Validation

Unit Testing: Data and model logic validation
Integration Testing: End-to-end pipeline testing
Model Evaluation: Performance metrics on holdout sets
A/B Testing: Compare models in production with real user traffic
Fairness & Bias Detection: Ensure model equity across demographics

4. Deployment & Serving

Containerization: Docker for reproducible environments
Orchestration: Kubernetes for managing deployments at scale
Model Serving: REST APIs, gRPC, batch inference, real-time serving
Version Management: Blue-green deployments, canary releases, rollback capabilities

5. Monitoring & Governance

Performance Monitoring: Track model predictions, latency, throughput
Data Drift Detection: Alert when input distributions change
Model Decay: Monitor accuracy degradation over time
Audit Trails: Compliance logging for regulated industries
Cost Optimization: Track infrastructure and compute costs

MLOps Workflow

From Experimentation to Production

Notebook Experimentation
        ↓
Feature Engineering & Versioning
        ↓
Model Training Pipeline (Automated)
        ↓
Model Validation & Testing
        ↓
Model Registry & Packaging
        ↓
Containerization & Artifact Storage
        ↓
Deployment to Staging Environment
        ↓
A/B Testing & Validation
        ↓
Production Deployment
        ↓
Monitoring & Alerting
        ↓
Retraining Triggers (Data/Model Drift)
        ↓
Loop Back to Training

Popular MLOps Tools

Experiment Tracking & Model Management

MLflow: Open-source platform for managing ML lifecycle
Weights & Biases: Cloud-based experiment tracking and hyperparameter optimization
Neptune.ai: Lightweight experiment tracking for teams

Data Management

DVC (Data Version Control): Version control for data and pipelines
Apache Airflow: Workflow orchestration and DAG scheduling
Prefect: Modern data orchestration platform
Delta Lake: ACID transactions for data lakes

Model Serving

TensorFlow Serving: Specialized serving for TensorFlow models
Seldon Core: Open-source model serving platform on Kubernetes
BentoML: Framework for packaging and deploying ML models
Ray Serve: Distributed model serving framework

Monitoring & Observability

Datadog: Infrastructure and APM monitoring
Prometheus + Grafana: Metrics collection and visualization
WhyLabs: ML model monitoring and data quality
Arize: ML model monitoring and explainability

Infrastructure & Operations

Kubernetes: Container orchestration
Docker: Containerization
Terraform: Infrastructure as Code
Jenkins / GitLab CI / GitHub Actions: CI/CD pipelines

MLOps Best Practices

Development

Treat data like code
- Version datasets and transformations
- Automate data pipeline testing
- Document data lineage
Reproducibility First
- Lock dependencies (requirements.txt, environment.yml)
- Document model training steps
- Store random seeds and hyperparameters
Modular Design
- Separate feature engineering from model training
- Use configuration files (YAML, JSON) for hyperparameters
- Build reusable components

Testing

Comprehensive Testing Strategy
- Unit tests for data transformations
- Integration tests for full pipelines
- Model performance tests against baselines
- Test edge cases and adversarial inputs
Automated Validation
- Schema validation for inputs and outputs
- Range checks for features
- Bias and fairness audits

Deployment

Infrastructure as Code
- Define environments declaratively
- Version control infrastructure changes
- Automate provisioning
Progressive Rollouts
- Start with canary deployments (1-5% traffic)
- Monitor metrics closely during rollout
- Have automated rollback mechanisms

Monitoring

Observability
- Log predictions and features
- Monitor model accuracy in real time
- Track data distributions for drift detection
- Set up alerts for anomalies
Feedback Loops
- Capture true labels as they become available
- Use actuals to retrain models
- Monitor feedback quality

Organization

Clear Ownership
- Define roles: data engineer, ML engineer, ML ops engineer
- Establish SLOs (Service Level Objectives) for models
- Document runbooks for common issues
Governance & Compliance
- Audit trail for model decisions
- Explainability/interpretability requirements
- Data privacy and regulatory compliance

Real-World Challenges

Technical Challenges

Data Quality: Garbage in, garbage out
Model Complexity: Balancing accuracy vs. interpretability vs. latency
Scalability: Handling millions of predictions per second
Reproducibility: ML experiments are inherently non-deterministic

Organizational Challenges

Silos: Data science isolated from engineering
Skills Gap: Few engineers understand both ML and infrastructure
Time to Market: Experimentation cycles are long
Cost Control: Compute resources can quickly become expensive

Getting Started with MLOps

Level 1: Manual Processes

Jupyter notebooks for experimentation
Manual model files and version tracking
Basic monitoring with logs

Level 2: Automated Pipelines

Automated training pipelines with cron jobs
Version control for code and models
Basic monitoring dashboards

Level 3: Continuous Integration

Automated testing on code changes
CI/CD pipelines for model training and deployment
Experiment tracking and model registries

Level 4: Full MLOps Maturity

End-to-end automation and orchestration
Advanced monitoring with drift detection
Automated retraining triggers
Multi-model experimentation and A/B testing
Governance and audit trails

Conclusion

MLOps is essential for scaling machine learning from experimentation to reliable, production systems. It bridges the gap between data science innovation and operational stability.

Key Takeaways:

MLOps combines ML, DevOps, and data engineering practices
Success requires automation at every stage
Monitoring and feedback loops are critical
Start simple and mature gradually
Team collaboration and clear processes matter as much as tools

The goal isn’t perfect tooling—it’s sustainable, scalable ML systems that deliver business value.

Personal Coding Agent

Fri, 30 Jan 2026 00:00:00 +0000

HAL9000

Introduction

HAL9000 is a personal coding agent. It is a powerful tool that can help you write code faster and more efficiently.

HAL9000 is written in Go and is designed to be easy to use and understand.

It uses Ollama, an open-source project that provides a simple API for advanced language models.

Features

TUI with lipgloss
Ollama API integration for advanced language models (Qwen3)

Tools

My coding agent should be able to create files, directories, and execute commands.

I started with create_file tool. I tested with Bruno.

Kokoro TTS

Tue, 20 Jan 2026 00:00:00 +0000

Text To Speech

Technology that enables text to be converted into speech sounds imitative of the human voice.

Run locally

https://github.com/remsky/Kokoro-FastAPI

docker run -p 8880:8880 ghcr.io/remsky/kokoro-fastapi-cpu:latest

And you can play with web ui:

http://localhost:8880/web

n8n workflow with Kokoro

I want to hear Qwen answer 😊

First I tested kokoro API with Bruno.

And then I added it to a new n8n workflow.

I had to remove all special characters.