Application & Data Migration Blog Posts | GAP Migrations

Model Context Protocol: A Bridge Between Legacy Desktop Applications and Modern AI

Written by DeeDee Walsh | May 25, 2025 3:17:23 AM

As someone who spends their days working with VB6 forms, PowerBuilder DataWindows, and Clarion templates, I'll admit that when I first heard about Microsoft's Model Context Protocol (MCP) support, my reaction was skepticism. "Great," I thought, "another modern protocol that'll be completely irrelevant to the world of COM objects and Win32 APIs."

I was wrong. 

The Legacy Reality Check

Let me paint you a picture. At GAP, we see it all:

  • VB6 applications that have been mission-critical since 1998
  • C# WinForms apps that were "temporary solutions" in 2005
  • PowerBuilder systems managing enterprise data with interfaces older than some of our junior developers
  • Clarion applications that nobody wants to touch because "if it ain't broke..."

These systems represent billions of dollars in business logic, carefully crafted over decades. They can't just be thrown away. But they also can't stay frozen in time while the world moves toward AI-assisted everything.

Enter MCP: The Unexpected Bridge

Model Context Protocol isn't just another API standard for the cloud-native crowd. It's actually a lifeline for legacy applications. Here's why:

1. Separation of Concerns That Legacy Developers Already Understand

MCP's architecture enforces clean separation between AI models and tools. Sound familiar? It should. This is exactly the kind of architectural pattern we preach when migrating legacy code. Your VB6 business logic doesn't need to know about AI models—it just needs to expose its capabilities through a standardized interface.

2. The C# SDK Changes Everything

Microsoft's collaboration with Anthropic on the official C# SDK is a game-changer for legacy migration scenarios. Why? Because we can now:

  • Wrap legacy COM components in MCP servers
  • Expose WinForms applications' functionality without touching the UI layer
  • Create facades around PowerBuilder non-visual objects
  • Bridge Clarion procedures to modern AI tools

Here's a simple example of how we might expose a legacy inventory system:

// Wrapping a legacy COM component as an MCP server
public class LegacyInventoryMCPServer : MCPServer
{
    private dynamic _legacyCOM;
    
    public LegacyInventoryMCPServer()
    {
        // Initialize the legacy COM component
        Type comType = Type.GetTypeFromProgID("InventorySystem.Manager");
        _legacyCOM = Activator.CreateInstance(comType);
    }
    
    [MCPTool("check_inventory")]
    public async Task<InventoryResult> CheckInventory(string productCode)
    {
        // Call the legacy method
        var result = _legacyCOM.GetStockLevel(productCode);
        
        // Transform to modern format
        return new InventoryResult
        {
            ProductCode = productCode,
            QuantityOnHand = result.QOH,
            LastUpdated = DateTime.Now
        };
    }
}

 

3. Security and Governance for the Enterprise

Legacy applications often handle sensitive business data. The Azure API Management integration with MCP addresses our biggest concerns:

  • OAuth 2.1 support means we can secure legacy functionality with modern authentication
  • Centralized registries help us track which legacy systems are exposed
  • Enterprise-grade logging and monitoring for compliance

4. Incremental Migration Path

This is the real beauty of MCP for legacy systems. Instead of the "big bang" rewrite that fails 70% of the time, we can:

  1. Wrap existing functionality in MCP servers
  2. Let AI agents interact with legacy systems safely
  3. Gradually modernize components while maintaining compatibility
  4. Eventually replace legacy implementations without changing the MCP interface

Real-World Scenarios

Let me share some scenarios we're actively exploring:

VB6 Order Processing System: A client has a VB6 application that processes 10,000 orders daily. By wrapping it in an MCP server, their support team can now use GitHub Copilot to query order status, debug issues, and even generate reports—all without touching the VB6 code.

PowerBuilder Financial Calculator: Complex financial calculations locked in PowerBuilder can now be exposed via MCP, allowing modern web applications and AI assistants to leverage decades of refined business logic.

WinForms CRM Integration: A C# WinForms CRM from 2008 can now participate in modern workflows. Sales teams use AI agents that query customer data through MCP, combining it with modern data sources for insights.

The Migration Strategy

Here's our recommended approach for legacy teams:

  1. Inventory Your Assets: Identify which legacy components contain valuable business logic
  2. Start Small: Pick one non-critical component and create an MCP wrapper
  3. Test with Internal Tools: Use VS Code's MCP support to validate your implementation
  4. Secure and Scale: Leverage Azure API Management for production deployment
  5. Monitor and Iterate: Use telemetry to understand usage patterns and plan modernization

Looking Forward

MCP isn't a silver bullet that magically modernizes legacy code. But it is a powerful tool that lets legacy applications participate in the AI revolution without requiring complete rewrites.

For those of us in the migration business, this is exciting. We can now offer clients a path that:

  • Preserves their investment in legacy systems
  • Enables AI integration today, not after a multi-year rewrite
  • Provides a stepping stone to eventual modernization
  • Reduces risk by maintaining proven business logic

Getting Started

If you're sitting on legacy desktop applications and wondering how to move forward, here's my advice:

  1. Download the C# MCP SDK
  2. Pick your simplest legacy component with clear inputs/outputs
  3. Create a basic MCP wrapper
  4. Test it with VS Code's MCP support
  5. Show your stakeholders an AI assistant interacting with their 20-year-old system

The reactions are awesome.

MCP Bottom Line

Model Context Protocol represents something we rarely see in technology: a modern standard that actually helps legacy systems rather than ignoring them. For those of us who build bridges between the old and new, MCP is a gift.

Yes, your VB6 application can participate in the AI revolution. Yes, your PowerBuilder system can provide context to language models. And yes, your WinForms app can be part of modern development workflows.

The future doesn't require abandoning the past. Sometimes, it just requires building better bridges.

At GAP, we specialize in modernizing legacy applications. If you're interested in exploring how MCP can help your legacy systems participate in modern AI workflows, reach out to our team. We've been bridging technology gaps for decades—this is just the latest bridge we're excited to help you cross.
View full post