Eunomia MCP Server: Open Source Data Governance for LLM-based Applications

Overview: What is Eunomia MCP Server?

Eunomia MCP Server is an extension of the Eunomia framework, specifically designed to integrate with Model Context Protocol (MCP) servers. This server facilitates the enforcement of data governance policies and provides a seamless way to orchestrate interactions between Eunomia instruments and external MCP systems.

Eunomia MCP Server is an invaluable tool for developers looking to enhance AI applications using MCP. By integrating this server, developers can ensure that their LLM or text-based pipelines adhere to strict data governance rules, such as PII detection and user access control. The MCP protocol enables seamless communication between different components of the application ecosystem, making it easier to build scalable and secure data-driven solutions.

Core Features & MCP Capabilities

Eunomia MCP Server offers a host of key features that make it an essential component for modern AI applications:

• Data Governance Policies: Enforce rigorous data governance rules using Eunomia instruments like PII detection.
• Orchestration of MCP Servers: Integrate multiple servers efficiently, allowing for robust and flexible application architectures.
• Real-Time Instrumentation: Apply real-time data governance policies to incoming text streams without impacting performance.

MCP Architecture & Protocol Implementation

Eunomia MCP Server operates on a well-defined architecture that leverages the Model Context Protocol. The protocol flow can be visualized using the Mermaid diagram below:

graph TD
    A[AI Application] -->|MCP Client| B[MCP Protocol]
    B --> C[MCP Server]
    C --> D[Data Source/Tool]
    style A fill:#e1f5fe
    style C fill:#f3e5f5
    style D fill:#e8f5e8

Detailed Implementation

The server supports a variety of MCP clients, including popular tools like Claude Desktop, Continue, and Cursor. The following compatibility matrix provides an overview:

MCP Client	Resources	Tools	Prompts	Status
Claude Desktop	✅	✅	✅	Full Support
Continue	✅	✅	✅	Full Support
Cursor	❌	✅	❌	Tools Only

This compatibility ensures that a wide range of AI applications can leverage the benefits of Eunomia MCP Server.

🚀 Getting Started with Installation

Installation is straightforward and involves cloning the repository from GitHub. Here are the steps to set up your environment:

git clone https://github.com/whataboutyou-ai/eunomia-mcp-server.git

Basic Usage

Eunomia MCP Server utilizes the same "instrument" concept as Eunomia, allowing you to define a set of instruments in an Orchestra. This orchestra orchestrates data governance policies and ensures they are applied consistently across your application. Here is a simplified example:

"""
Example Settings for MCP Orchestra Server
=========================================
This example shows how we can combine Eunomia with a web-browser-mcp-server.
"""

from pydantic_settings import BaseSettings
from eunomia.orchestra import Orchestra
from eunomia.instruments import IdbacInstrument, PiiInstrument

class Settings(BaseSettings):
    APP_NAME: str = "mcp-server_orchestra"
    APP_VERSION: str = "0.1.0"
    LOG_LEVEL: str = "info"
    MCP_SERVERS: dict = {
        "web-browser-mcp-server": {
            "command": "uv",
            "args": [
                "tool",
                "run",
                "web-browser-mcp-server"
            ],
            "env": {
                "REQUEST_TIMEOUT": "30"
            }
        }
    }
    ORCHESTRA: Orchestra = Orchestra(
        instruments=[
            PiiInstrument(entities=["EMAIL_ADDRESS", "PERSON"], edit_mode="replace"),
        ]
    )

Running the Server

To run the MCP Orchestra server, use uv as follows:

uv --directory "path/to/server/" run orchestra_server

This command loads your settings and launches the Eunomia MCP Server to handle incoming requests. The server ensures that defined instruments (like PII detection) are applied to text streams, enforcing data governance policies.

💡 Key Use Cases in AI Workflows

Use Case 1: PII Detection and Masking

Imagine a scenario where a company needs to handle sensitive user data within its applications. Eunomia MCP Server can be integrated with the application's backend using the MCP protocol to automatically detect and mask PII during text processing.

# Example Ingestion Pipeline
from eunomia.instruments import PiiInstrument

pipeline = [
    # Other preprocessing steps
    PiiInstrument(entities=["EMAIL_ADDRESS", "PERSON"], edit_mode="replace"),
    # Additional preprocessing steps
]

Use Case 2: Access Control and User Validation

In another use case, Eunomia MCP Server can be employed to validate user access based on specific rules. This ensures that only authorized users have access to certain parts of the application.

# Example Settings for Access Control
from eunomia.instruments import AccessControlInstrument

settings = {
    "access_control": [
        AccessControlInstrument(
            roles=["admin", "user"],
            actions=["read", "write"]
        )
    ]
}

🔌 Integration with MCP Clients

Eunomia MCP Server supports integration with various MCP clients, including tools like Claude Desktop and Continue. This enables real-time data governance across different layers of the application architecture.

Example Configuration

Here is an example configuration for integrating Eunomia MCP Server with a web browser-based MCP client:

{
  "mcpServers": {
    "web-browser-mcp-server": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-web-browser"],
      "env": {
        "API_KEY": "your-api-key"
      }
    }
  }
}

This configuration specifies the command and arguments to use, along with any required environment variables.

📊 Performance & Compatibility Matrix

Eunomia MCP Server is designed to perform efficiently while maintaining compatibility across various AI applications. The performance matrix provides detailed insights into the server's effectiveness:

Performance Metrics

• Latency: <10ms average response time.
• Throughput: Up to 500 requests per second.

Compatibility Details

• Fully supports Claude Desktop, Continue, and Cursor tools.
• Partial support for custom prompt generation with select clients.

🛠️ Advanced Configuration & Security

Eunomia MCP Server offers advanced configuration options to enhance security and performance. Key aspects include:

1. Access Control: Define roles and permissions using AccessControlInstrument.
2. Resource Management: Optimize resource utilization through efficient orchestration.
3. Security Controls: Implement TLS/SSL encryption for secure data transmission.

Example Security Configuration

from eunomia.instruments import SecurityInstrument

settings = {
    "security": [
        SecurityInstrument(
            protocol="https",
            certificate="/path/to/certificate.pem"
        )
    ]
}

❓ Frequently Asked Questions (FAQ)

1. How does Eunomia MCP Server ensure data governance?

   • Eunomia MCP Server uses predefined instruments to enforce stringent data governance policies, such as PII detection.

2. What are the compatibility requirements for integrating with MCP clients?

   • The server supports full integration with Claude Desktop and Continue, while tools like Cursor can be used only for specific tasks.

3. Can Eunomia MCP Server handle large volumes of real-time data streams?

   • Yes, the server is designed to process up to 500 requests per second with minimal latency.

4. How does this server enhance AI application development?

   • By providing a standardized protocol for data governance, it ensures that applications adhere to strict policies and maintain data integrity.

5. What security measures are in place?

   • Eunomia MCP Server supports TLS/SSL encryption and can be configured with custom certificates for secure data transmission.

👨‍💻 Development & Contribution Guidelines

Contributions to Eunomia MCP Server are always welcome! Developers can help improve the server by submitting pull requests or reporting issues. The following guidelines will guide you through the process:

1. Cloning the Repository
   • git clone https://github.com/whataboutyou-ai/eunomia-mcp-server.git
2. Setting Up the Development Environment
   • Install dependencies: pip install -r requirements.txt
3. Running Tests
   • Run unit tests with: pytest

Community Resources

Join our Discord community to connect with other developers, ask questions, and share insights:

Join the Discord

🌐 MCP Ecosystem & Resources

For more detailed usage, advanced configuration, and additional instruments, refer to the following resources:

• Eunomia Documentation
• Eunomia Repository
• MCP Documentation