Enterprise MCP Server for LLM Integration

Overview

The Enterprise MCP Server, or mcp-ectors for short, is an enterprise-ready, high-performance, and secure MCP server designed to enable seamless integration and interaction between large language models (LLMs) and various tools, resources, and workflow prompts. Built using Rust, Wasm, and actors, it is optimized for performance, security, and scalability, making it a great fit for enterprise environments.

Key Features

• Wasm Wasix MCP Router: The default way to create and manage MCPs through a Wasm-based approach with Wasix.
• Wasm Support: With Wasm support built via Wasix-MCP.router, mcp-ectors offers a lightweight and flexible platform for running various MCPs.
• High Performance: Built with actors and Rust, the server ensures high scalability and concurrency.
• MCP as the USB for LLMs: Enables access to tools, resources, and workflow prompts through a clean API.
• Reuse Connections: Allows multiple routers to be deployed on the same connection, simplifying architecture and resource management.
• Multiple Routers: Register multiple routers and utilize them dynamically through the Router Service Manager.

Getting Started

Prerequisites

To get started with mcp-ectors, make sure you have the following installed:

• Rust (via rust-lang)
• Cargo (comes with Rust)
• Cargo run for running the application.

Running the Server

1. Clone the repository:
   shell git clone https://github.com/yourusername/mcp-ectors.git cd mcp-ectors

2. Run the server:
   shell cargo run
   The server will start on http://localhost:8080/sse.

3. Start with the Goose Desktop: In Goose Desktop (a companion tool), you can add extensions, choose SSE as the transport, and use the following URL:
   httpspec http://localhost:8080/sse

Using the Counter Example

1. After running the server, in the Goose Desktop application you can ask to increment the counter or get the current value.
2. Try also Hello World greet.

Create New MCP Routers

MCP-ectors enables you to create and register new routers through the Router Trait. To add a new router, implement the Router trait for your new router, following the examples of the existing CounterRouter or HelloWorldRouter.

Example:

use exports::wasix::mcp::router::{Role::User, Annotations, ToolsCapability, ResourcesCapability, PromptsCapability, CallToolResult, Content::Text, GetPromptResult, Guest, McpResource, Prompt, PromptMessage, PromptMessageContent, PromptMessageRole, ReadResourceResult, ResourceContents, ResourceError, ServerCapabilities, TextContent, TextResourceContents, Tool, ToolError, PromptError, Value};

wit_bindgen::generate!({
    path: "wit/world.wit",
    world: "mcp",
});

#[derive(Clone)]
pub struct MyRouter;

impl Guest for MyRouter {
    fn name() -> String {
        "MyRouter".to_string()
    }

    fn instructions() -> String {
        "Your instructions go here".to_string()
    }

    fn capabilities() -> ServerCapabilities {
        ServerCapabilities {
            tools: Some(ToolsCapability{ list_changed: Some(true) }),
            resources: Some(ResourcesCapability{ subscribe: Some(true), list_changed: Some(false)}),
            prompts: Some(PromptsCapability{ list_changed: Some(true) }),
        }
    }

    fn list_tools() -> Vec<Tool> {
        ...
    }

    fn call_tool(
        tool_name: String,
        arguments: Value,
    ) -> Result<CallToolResult, ToolError> {
        ...
    }

    fn list_resources() -> Vec<McpResource> {
        ...
    }

    fn read_resource(
        uri: String,
    ) -> Result<ReadResourceResult, ResourceError> {
        ...
    }

    fn list_prompts() -> Vec<Prompt> {
        ...
    }

    fn get_prompt(prompt_name: String) -> Result<GetPromptResult, PromptError> {
        ...
    }
}

export!(YourRouter);

Registering Routers

In MCP, tools, resources, and prompts are registered as routerid_tool, routerid_prompt, and routerid_resource to keep everything well-organized. The Router Service Manager adds new routers by dropping the .wasm file in the wasm directory the server loads from.

Example Registration:

Just start the server via mcp-ectors start --wasm_path wasm and drop your MPC router wasms in the directory.

Architecture Overview

1. Server Builder:

   • The server_builder determines the transport layer. Currently, SSE is supported. Future versions will include stdio and wasi transport.
   • For now, the server supports SSE for communication between the client and the server.

2. Router Service Manager:

   • The RouterServiceManager is responsible for registering multiple routers and ensuring that each router can handle requests without the need for new connections.
   • This architecture allows you to deploy several routers with the same connection, making the system highly efficient and scalable.

3. Log Configuration:

   • The server can be configured to store logs in specific directories and set custom log levels for monitoring and debugging.
   • The configuration can be customized using the LogConfig struct.

4. Transport Actor:

   • Any transport used in the MCP server needs to implement the transport actor. The TransportActorTrait ensures that transports handle requests and messages correctly:
     • TransportRequest: Allows new JsonRPCMessages to be sent to the client.
     • StartTransport: This message starts the transport, initializing any necessary background tasks.
     • StopTransport: This message stops the transport, gracefully shutting down any active connections or tasks tied to the transport layer.

5. Router:

   • The Router is a trait that any router needs to implement, closely linked to the MCP standard. The RouterServiceManager uses the RouterRegistry to register new routes.

6. Standard Actors:

   • MCP has a set of standard actors that implement basic functions such as initialization and managing tools, prompts, and resources.

Example Log Configuration:

let log_config = LogConfig {
    log_dir: "logs".to_string(),
    log_file: "server.log".to_string(),
    level: Level::INFO,
};

Future Development

• MCP Protocol: The basics have been implemented but notifications are still missing. Also oAuth, secrets management,... are on the roadmap.
• Transport Extensions: Currently, the server supports SSE transport, with plans to add stdio and wasi in the future.
• Help Wanted: Contributions are welcome! If you have expertise in other transports like WASI or stdio, feel free to submit a PR.

Conclusion

The MCP SSE Server (mcp-ectors) is built for high performance, scalability, and ease of use. With actors, Rust, and a clean architecture for managing multiple routers, it makes working with LLMs, tools, and resources effortless.

Feel free to contribute, test, and expand the system for your enterprise use cases. You can rely on mcp-ectors to power your next-generation AI applications. If your company wants to create custom routers or partner, please reach out to Maarten Ectors.

About

The MCP enterprise actors-based server or mcp-ectors for short.

Resources

Readme

License

MIT license

Activity

Stars

17 stars

Watchers

1 watching

Forks

0 forks

Report repository

Releases

No releases published

Packages 0

No packages published

Contributors 2

• 
  mcp-ectors Maarten Ectors

• 
  profitgrowinginnovator Maarten Ectors

Languages

• Rust 100.0%