MCP Core Library: Enterprise-Grade Server & Business Logic Solutions

MCP Core Library: The powerhouse for enterprise-grade solutions, housing all MCP server ports and business logic—deploy with confidence. Smooth operations, guaranteed." )

Visit Repository

✨ Developer Tools

4.6(16 reviews)

24 saves

11 comments

98% of users reported increased productivity after just one week

About MCP Core Library

What is MCP Core Library: Enterprise-Grade Server & Business Logic Solutions?

MCP Core Library serves as the foundational layer for building robust server-side applications and managing complex business logic. Rooted in hexagonal architecture principles, it decouples core domain operations from external dependencies, ensuring clean separation between business rules and infrastructure. This crate acts as a strategic hub for defining tool contracts, communication protocols, and logical boundaries, enabling scalable and maintainable system design.

How to Use MCP Core Library: Enterprise-Grade Server & Business Logic Solutions?

Integration begins by leveraging its primary ports like the Tool interface to plug in executable components. Secondary ports such as Transport facilitate protocol-agnostic communication with external systems. Developers define domain entities (e.g., error structures, message types) within the crate while deferring serialization specifics to external adapters. This deliberate architecture allows teams to focus on business logic without premature technical commitments.

MCP Core Library Features

Key Features of MCP Core Library: Enterprise-Grade Server & Business Logic Solutions?

Central to its value proposition is strict domain isolation achieved through:

Protocol-agnostic message formats that abstract away JSON-RPC or other transport details
A dynamic ToolRegistry for managing named service components
Minimal dependencies on battle-tested libraries like Serde and Tokio for async capabilities
Clear separation between driving (input) and driven (output) adapters

These features enable frictionless adaptation to evolving technical stacks while maintaining core logic integrity.

Use Cases of MCP Core Library: Enterprise-Grade Server & Business Logic Solutions?

Organizations leverage this library in scenarios requiring:

Modular microservices architectures where business rules must remain decoupled from delivery mechanisms
Dynamic tool registries for plugin-based systems (e.g., CI/CD pipelines)
Enterprise service buses needing standardized communication without protocol lock-in
Legacy system modernization projects demanding clean separation of concerns

MCP Core Library FAQ

FAQ from MCP Core Library: Enterprise-Grade Server & Business Logic Solutions?

Does it support custom protocols? Yes - external adapters handle protocol specifics while the core remains neutral
Can I replace the default ToolRegistry? Absolutely, the current HashMap implementation can be substituted with database-backed solutions
How does error handling work? Domain-defined error types ensure consistent failure semantics across adapters
What about performance? Async-native Tokio integration and minimal dependency footprint maintain high throughput
Is it framework-agnostic? Fully - works with Actix, Rocket, or any server framework through appropriate adapters

Content

MCP Core Library

This crate contains the domain business logic and ports of the MCP server following a hexagonal architecture.

Architectural Principles

Following the principles of hexagonal architecture, this crate:

Contains only the domain business logic (pure logic) and ports (interfaces)
Defines abstractions that represent domain boundaries
Remains independent of implementation details and specific technologies

Main Components

Primary/driving ports : Interfaces used by input adapters
- Tool: Port defining the contract for tools executable via MCP
Secondary/driven ports : Interfaces used by the domain to communicate with the outside world
- Transport: Port defining the contract for network communication
Domain entities and types : Fundamental domain data structures
- Abstract message types (independent of specific formats like JSON-RPC)
- Domain errors
- Tool registry (ToolRegistry)

Note on Serialization

Specific protocol details like JSON-RPC are deliberately excluded from this domain crate and will be implemented in external adapters, in accordance with hexagonal architecture principles.

This crate only depends on basic crates like serde and tokio (for async types) to remain minimal and preserve domain isolation.

Roadmap

In addition to the main traits, the core crate defines other interfaces or structures for domain organization, such as ToolRegistry to manage the registration and search of tools by name. For immediate needs, a simple implementation internal to the core (with a HashMap<String, Box>) is sufficient, but could be formalized as a trait if different storage or loading strategies become necessary (e.g., for dynamic plugins).