First came chatbots, then AI-powered coding assistants such as GitHub Copilot, and today we have entered the era of AI Agents-systems capable not only of answering questions but also of interacting with external tools, databases, Git repositories, CRMs, and enterprise applications.

In this rapidly evolving landscape, a new standard is emerging that is likely to become increasingly important: Model Context Protocol (MCP).

Although it is still relatively unknown today, it will likely become one of the fundamental concepts every software developer should understand.

What is Model Context Protocol?

Model Context Protocol, commonly referred to as MCP, is an open protocol designed to enable AI models to communicate with applications, services, and data sources through a standardized interface.

Simply put, it provides a common language between AI models and the tools we use every day.

Let’s look at a simple example.

Imagine asking an AI assistant:

“Show me all the orders placed today by customer Rossi.”

Without MCP, the assistant would need to understand the ERP’s specific APIs, authentication methods, response formats, and custom integration logic.

With MCP, all of this is standardized.

The AI doesn’t need to know how every individual application works internally. Instead, it communicates through a shared protocol that any compatible service can expose.

Why was MCP created?

Until recently, every integration with a Large Language Model required custom development.

Every application exposed different APIs.

Every authentication method was unique.

Every response followed its own format.

The result?

Developers spent a considerable amount of time building integrations that were difficult to reuse.

Model Context Protocol was created to solve exactly this problem.

Just as HTTP standardized communication between web browsers and web servers, MCP aims to standardize communication between AI models and software applications.

How does it work?

The overall architecture is remarkably simple.

On one side, there is the AI model.

On the other, one or more MCP servers expose tools, data, and capabilities.

When a user submits a request, the AI model can:

• query databases;
• search documentation;
• interact with a CRM;
• browse Git repositories;
• read local files;
• call REST APIs;
• retrieve enterprise data;
• execute authorized operations.

The model doesn’t guess how to interact with external systems. It knows which tools are available and uses them through a standardized protocol.

This makes integrations significantly more reliable and predictable than custom-built solutions.

A real-world example

Imagine a company that uses:

• a CRM;
• an ERP;
• a customer database;
• a document management system;
• Git repositories;
• a ticketing platform.

Today, enabling an AI assistant to work with all these systems would require numerous custom integrations.

With MCP, each system can expose its capabilities as standardized tools.

The AI assistant can then:

• retrieve business data;
• compare information across systems;
• generate reports;
• create documentation;
• assist developers and support teams.

All without reinventing the integration logic every time.

Why developers should pay attention

Many people believe AI will reduce the need for software developers.

Personally, I think the reality is different.

What will change is the nature of our work.

We’ll spend less time writing repetitive code and more time designing architectures, defining workflows, integrating systems, and building tools that AI can safely interact with.

In this context, understanding MCP could become a real competitive advantage.

MCP and programming languages

One of MCP’s biggest strengths is that it is language-agnostic.

MCP servers can be implemented using virtually any modern programming language, including:

• PHP;
• C# and .NET;
• Java;
• JavaScript and Node.js;
• Python;
• Go;
• Rust.

This means existing applications can become AI-ready without requiring a complete rewrite.

Possible use cases

The possibilities are virtually endless.

Using technologies I’m most familiar with as examples, a Drupal website could expose capabilities that allow an AI assistant to:

• create content;
• search articles;
• edit pages;
• query Views;
• retrieve analytics.

An ASP.NET application could expose tools to:

• query databases;
• manage users;
• generate reports;
• retrieve documents.

A PHP-based ERP or business application could allow AI to:

• verify customer orders;
• check inventory availability;
• prepare quotations;
• retrieve invoices.

All through the same open standard.

The future of AI Agents

More and more companies are investing in AI Agents, and the difference compared to traditional chatbots is significant.

A chatbot answers questions.

An AI Agent gets work done.

It can use tools, make decisions within predefined limits, retrieve information, and collaborate with multiple business systems.

To do this effectively, however, it needs a standardized way to access external resources.

That is exactly where MCP comes in.

Is it worth learning today?

In my opinion, absolutely.

We’re at a stage that feels very similar to where REST APIs were fifteen years ago.

Back then, they seemed like a niche technology used by only a handful of developers.

Today, REST APIs are at the heart of virtually every modern application.

I believe Model Context Protocol could follow a similar path.

It won’t replace traditional APIs, but it will become an additional layer that makes it much easier for AI models to interact with the software we use every day.

Final thoughts

Artificial Intelligence isn’t just changing the way we write code.

It’s changing the way software systems communicate with one another.

I believe Model Context Protocol represents one of the first serious attempts to establish a shared standard between AI models and software applications.

For this reason, I believe that learning MCP today means preparing for a transformation that has already begun.

Just as cloud computing, Docker, Kubernetes, and REST APIs reshaped software engineering over the past decade, developers who start experimenting with MCP today will likely have a significant advantage when this technology becomes part of everyday software development.

Personally, I believe that in the coming years we’ll hear less about simple chatbots and far more about intelligent applications designed from the ground up to collaborate with AI through open standards such as Model Context Protocol.

L'articolo MCP: The Technology Few Are Talking About That Could Change the Way Developers Work proviene da Giovanni Anfuso.

When talking about CMS platforms in the .NET ecosystem, people often think of tools designed primarily to build websites. Orchard Core, however, was created with a different idea in mind: not just to manage content, but to serve as a foundation for building web software.

Orchard Core is an open-source project built on ASP.NET Core and represents a complete modern rewrite of the original Orchard CMS. The key difference is that it is not just a CMS: it is first and foremost a modular multi-tenant framework on top of which the content management system is built.

In practice, it can be used in two ways:

• as a traditional CMS
• as an application platform for building software products

This completely changes how it should be interpreted: it is not a direct competitor to classic website-focused CMS platforms, but a tool designed for projects meant to grow over time.

A CMS Designed as a Platform

The philosophy behind Orchard Core is simple: start minimal and add only what is needed.

Every feature is an activatable module. The result is a system that never becomes inherently heavy, because the application includes only the components actually in use.

This approach leads to two important consequences:

The first is technical: the codebase remains clean, maintainable, and upgradable even after years.

The second is architectural: the CMS becomes the foundation for complex applications, not just editorial websites.

Not surprisingly, the framework is also designed to build modular SaaS software, where multiple teams can develop different parts of the same product and reuse them across projects.

Multi-Tenant: The Feature That Changes Everything

The real core of Orchard Core is its native multi-tenancy.

With a single installation, it is possible to manage multiple completely separate sites: databases, users, themes, and configurations remain isolated. This is not simulated multisite functionality, but truly independent environments sharing only the engine.

This makes it particularly suitable for:

• SaaS platforms
• multi-brand corporate portals
• white-label solutions
• agencies managing many clients

In cloud environments, it is possible to host thousands of sites on a single infrastructure while maintaining full data isolation.

Performance and Modern Architecture

One of the main goals of the rewrite was speed.
The CMS was designed to leverage the ASP.NET Core pipeline and a data management approach different from traditional CMS platforms.

Although it uses relational databases, it adopts a document abstraction layer (YesSql) that allows content to be treated as documents, improving performance in typical CMS operations.

The result behaves much more like a web application than a traditional dynamic website.

Headless, Decoupled, or Traditional

One of Orchard Core’s most interesting qualities is architectural freedom.
It can be used in different ways without changing platforms:

• full website with themes and templates
• content backend for custom frontends
• headless CMS via GraphQL or REST APIs

In other words, it adapts to the project instead of forcing the project to adapt to the CMS.

Security

From a security perspective, Orchard Core inherits ASP.NET Core protections and adds highly granular permission management.

Each role can have specific access to content, administrative sections, and features. External authentication, approval workflows, and tenant isolation are supported.

This structure makes it suitable for enterprise and public-sector environments, where access management is often the critical factor.

Scalability and Cloud

Orchard Core was designed with scalability in mind from the very beginning, not added later.

It runs smoothly in Docker containers, cloud environments, and distributed architectures. Native multi-tenancy makes it easy to transform into the engine behind a software product.

It is therefore more accurate to compare it to an application platform with an integrated CMS rather than a simple editorial tool.

Scalability is one of the main reasons to choose Orchard Core:

• native multi-tenancy
• Docker container deployment
• cloud-ready architecture
• hosting thousands of sites in parallel
• per-client data isolation

Database and Flexible Data Management

It supports:

• SQL Server
• MySQL / MariaDB
• PostgreSQL
• SQLite

It uses a document-oriented abstraction layer (YesSql) on top of relational databases — an approach that improves performance in modern CMS environments.

In practice, it is designed more for platforms than for individual websites.

When It Makes Sense to Choose It

Orchard Core becomes particularly interesting when a project has these characteristics:

• it needs to grow over time
• it includes separate clients or environments
• it is intended to become a commercial product
• it requires integration with other systems
• it uses an enterprise .NET stack

SaaS and Platforms

• software delivered as a service
• customized customer portals
• white-label applications

Enterprise and Intranet

• document management
• approval workflows
• corporate portals

Headless CMS

• content backend for mobile apps
• React/Vue/Angular frontends
• custom ecommerce solutions

Multi-site

• brand networks
• publishing groups
• franchises

On the other hand, it is often oversized for small informational websites or simple blogs, where its real strengths would remain underutilized.

Community and Ecosystem

The community is not massive but highly technical and development-oriented.
The project is active, regularly updated, and maintained by experienced ASP.NET developers.

The documentation is extensive and geared more toward application developers than purely editorial users — another indication of its true nature.

Final Personal Considerations

Orchard Core is not an open-source CMS that can be evaluated at a glance: it appears to be a content management tool, but in reality it is an application platform that includes a CMS.

It is designed for complex web software, multi-client portals, and SaaS solutions. In these scenarios, it offers enormous advantages in terms of maintenance, scalability, and project organization.

If your goal is simply to publish content quickly, simpler solutions exist.
If instead you are building a system meant to last for years, it is likely exactly the kind of foundation worth starting from.

L'articolo Orchard Core: the Modular and Multi-Tenant .NET CMS for Scalable Applications proviene da Giovanni Anfuso.

In recent years, the CMS ecosystem has seen the emergence of solutions focused on performance, flexibility, and the ability to integrate with external services. Umbraco is one of them: an open-source Content Management System based on Microsoft .NET, designed to offer maximum extensibility, full content control, and an intuitive interface for both editors and developers.

What Is Umbraco CMS

Umbraco is a CMS built on the ASP.NET Core platform that enables the creation of websites, corporate portals, and digital applications with a high degree of customization. Unlike more “closed” CMS platforms, it relies on modern architectures and supports both traditional usage and headless approaches for multi-channel content delivery.

Key Features

Intuitive and Easy-to-Use Interface
Umbraco provides a simple yet powerful management panel: even non-technical users can create and update content easily thanks to visual tools and a drag-and-drop editor.

Maximum Flexibility and Customization
Its open structure allows every element of a website to be modeled: custom templates, tailored document types, and specific extensions for any project requirement.

Extensibility and API Integrations
Thanks to its API-first architecture, Umbraco integrates easily with CRMs, marketing tools, e-commerce platforms, and external services such as Google Analytics, HubSpot, or automation tools.

SEO and Performance
It supports advanced SEO practices: optimized URLs, metadata control (title, description, canonical), XML sitemaps, and robots management without the need for external plugins. Additionally, technologies such as caching and CDN compatibility improve page loading times.

Security and Access Control
Umbraco implements robust security measures, including regular updates, TLS/SSL support, multi-factor authentication, and granular user role management.

Multilingual and Multi-Site Management
Native support for multilingual and multi-site content makes it ideal for international projects or organizations managing multiple brands or domains from a single installation.

Why Choose Umbraco

Umbraco is appreciated for its balance between simplicity and advanced capabilities. It offers a solid framework for developers and an accessible environment for content editors, enabling projects ranging from corporate websites and informational portals to complex digital platforms.

Additionally, an active developer community and a rich package ecosystem allow the CMS to be continuously extended and updated while maintaining high performance and up-to-date security.

When to Use It

Umbraco is ideal if you want:

• full control over code and architecture
• custom integrations
• long-term scalability
• support for enterprise or multilingual projects

It is not generally the simplest “plug-and-play” solution for those looking for a zero-configuration CMS, but it excels when project customization and flexibility are the top priorities.

L'articolo Umbraco: the .NET CMS, Features, Advantages, and Use Cases proviene da Giovanni Anfuso.