Simplifying Legal Case Information Access with MCP and Claude

Transforming Enterprise Information Access Through Conversational AI

Client

DeCubas & Lewis

Fort Lauderdale, Florida

DeCubas & Lewis is a law firm specializing in default servicing, foreclosure, eviction, national bankruptcy, loss mitigation, and related litigation. Its technology platform supports the management of cases, transactions, events, fees, and other information required by users to manage and process legal matters.

Technology

• ASP.NET Core
• Model Context Protocol (MCP)
• Claude Desktop
• Existing application APIs
• Existing case-management data and business logic

Executive Summary

Legal case-management systems often contain large amounts of valuable information. However, having information available in a system does not necessarily mean that users can access it efficiently.

At DeCubas & Lewis, users relied on a web-based application to access case-related information such as transactions and events. Finding a specific piece of information typically required users to log in, locate the appropriate file, navigate through the relevant sections, and search for the required data.

For frequently requested information, this created unnecessary interaction and increased the time required to complete simple information-retrieval tasks.

To address this challenge, I developed an MCP server using ASP.NET Core that connects the existing application APIs with Claude Desktop.

The solution provides users with a conversational interface to existing application capabilities.

Instead of navigating through the application to find information, users can ask Claude questions such as:

“What were the recent transactions for file number 90-00000.”

or

“Give me the event list for file number 23-12025.”

Claude communicates with the MCP server, which invokes the appropriate application functionality and returns the requested information.

The result is a simpler interaction model that reduces the effort required to retrieve frequently accessed case information while preserving the existing application and business logic.

The Business Challenge

Information Was Available—Access Was the Bottleneck

The existing application already contained the information users needed.

The challenge was the process required to retrieve it.

A typical information request could require a user to:

1. Log into the application.
2. Locate the appropriate case or file.
3. Navigate to the relevant section.
4. Search for the required information.
5. Open the appropriate record.
6. Review the results.

For users who perform these tasks repeatedly, the navigation itself becomes part of the workload.

This creates an important distinction:

The problem was not data availability. The problem was information accessibility.

The goal was therefore not to replace the existing application, but to provide a simpler way for users to interact with its existing capabilities. 

Identifying the Opportunity

The key question was:

Can users interact with the existing application by asking for the information they need instead of manually navigating to it?

This led to exploring the Model Context Protocol (MCP) as an integration layer between a conversational AI client and the existing application APIs.

MCP provided an approach for exposing controlled application capabilities to an AI client without requiring the AI client to directly interact with the underlying database.

The Solution

An MCP-Powered Conversational Interface

I designed and implemented an MCP server using ASP.NET Core.

The MCP server acts as an intermediary between Claude Desktop and the existing application APIs.

The resulting architecture can be represented as:

The architecture intentionally builds on the existing application rather than duplicating its functionality.

How the Solution Works

Consider a user who needs the transaction history for a particular file.

Traditional workflow

The user would need to:

1.     Login
2.     Find the file
3.     Navigate to transactions
4.     Search/filter
5. Review transactions

MCP workflow

The user can simply ask:

“Give me the transactions list for file number 90-00000.”

The request follows this flow:

1.     User Question
2.     Claude Desktop
3.     MCP Client
4.     MCP Server
5.     Existing Application API
6.     Transaction Data
7.     MCP Server
8.     Claude
9.     User

The user doesn’t need to understand the application’s internal navigation or API structure. These examples may appear simple, but they represent a broader architectural capability: making existing enterprise functionality accessible through natural-language interaction.

Why MCP Instead of Direct Database Access?

A critical architectural decision was to avoid giving the AI client direct access to the underlying database.

The MCP server provides a controlled boundary between the AI client and the application.

Instead of exposing the entire data layer, the application can expose specific capabilities.

For example:

GetTransactions(fileNumber)

GetEvents(fileNumber)

This approach provides several architectural advantages.

Reuse Existing Business Logic

The existing APIs and application services remain responsible for business rules and data access. The MCP layer does not need to duplicate that logic.

Controlled Capabilities

Only explicitly defined operations can be exposed to the AI client.

Reduced Coupling

Claude does not need to understand the internal database structure.

Easier Expansion

Additional approved application capabilities can be exposed through new MCP tools as business requirements evolve.

The Real Value: Simplifying the Interaction Model

The most important outcome of the project is not simply that an AI system was introduced.

The larger improvement is the change in how users interact with enterprise software.

Traditional applications require users to understand the application’s structure.

For example:

“Where do I find transactions?”

A conversational interface allows the user to think in terms of the desired outcome:

“Show me the transactions for this file.”

That is a fundamentally different interaction model.

The software structure becomes less important to the user.

Why the Existing Application Still Matters

One of the important architectural principles behind the solution is that AI does not replace the existing application.

The existing system continues to provide:

• Business rules
• APIs
• Data access
• Case management
• Security controls

The MCP server adds another access layer.

This means the organization can introduce conversational capabilities without having to rebuild the core application.

The approach can therefore be viewed as:

Existing application + controlled AI interface

rather than:

Replace existing application with AI

Scalability of the Approach

The initial implementation focuses on easy retrieval. However, the architecture can support additional use cases where there is clear business value.

Potential future capabilities could include:

• Case information
• File status
• Fee information
• Matter information
• Event history
• Transaction summaries
• Document metadata
• Other frequently requested case information

Each capability can be evaluated and exposed independently through an MCP tool.

This provides a controlled path for gradually expanding the conversational interface.

Measuring Success

The initial goal of the project was to reduce the time and complexity involved in retrieving information.

To quantify the impact further, organizations can measure:

• Average time required to retrieve common information before and after implementation
• Number of navigation steps eliminated
• Frequency of MCP-based queries
• Most frequently requested information
• User adoption
• Successful versus unsuccessful requests
• Reduction in repetitive application searches
• User satisfaction

These measurements can help determine which additional capabilities provide the highest business value.

Conclusion

The MCP implementation at DeCubas & Lewis demonstrates a practical approach to introducing conversational AI into an existing enterprise application.

The organization already had the data, APIs, and business processes required to manage legal cases.

The opportunity was to make that information easier for users to access.

By building an ASP.NET Core MCP server and connecting it with Claude Desktop, users can interact with existing application capabilities through natural-language questions.

Instead of navigating through the application to find a transaction or event, a user can ask:

“Give me the transactions list for file number 90-00000.”

or:

“Give me the event list for file number 23-12025.”

The MCP server connects that request to the appropriate application API and returns the information through Claude.

The broader lesson is straightforward:

Enterprise AI does not always require replacing existing systems. Sometimes, the most valuable improvement is creating a simpler interface to the systems and information an organization already has.

For this project, MCP provided that interface—bringing conversational access to existing legal case-management capabilities while keeping the underlying application architecture and business logic intact.