Eunomia MCP Server Deprecated — New Integration Soon

Overview

Warning: this Eunomia MCP Server integration is deprecated and is not compatible with the latest Eunomia repository. A replacement MCP integration is under development — check back on the project repository for updates: https://github.com/whataboutyou-ai/eunomia-MCP-server.

The Eunomia MCP Server was an extension that connected Eunomia “instruments” (data-governance processors) to external MCP (Model Context Protocol) servers. It let you route text streams through Eunomia policies — for example, automatic PII detection/redaction or access-based transformations — while delegating input/output and UI concerns to MCP-compatible server processes.

This article summarizes how the project worked, the major features, and practical examples for developers who want to understand the integration pattern. Because the package is deprecated, treat the instructions as a reference for concepts and local experimentation rather than a production-ready integration.

Features

• Connects Eunomia Orchestra instruments to external MCP servers to enforce governance on text streams.
• Pluggable instruments: PII detection, ID-based access control (Idbac), and custom Eunomia instruments.
• Orchestrates multiple external MCP processes and forwards requests/responses through Eunomia pipelines.
• Settings-driven configuration (Pydantic-style) for server commands, arguments, and per-server environment.
• Designed to be run alongside MCP servers launched as subprocesses (e.g., via uv).

Installation / Configuration

Clone the repository to inspect the code or run locally:

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

Example settings using Pydantic-style BaseSettings (illustrative):

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

class Settings(BaseSettings):
    APP_NAME: str = "mcp-orchestra"
    APP_VERSION: str = "0.1.0"
    LOG_LEVEL: str = "info"

    # Define external MCP servers to launch and connect to
    MCP_SERVERS: dict = {
        "web-browser-server": {
            "command": "uv",
            "args": ["tool", "run", "web-browser-mcp-server"],
            "env": {"REQUEST_TIMEOUT": "30"}
        }
    }

    # Build an Orchestra with Eunomia instruments
    ORCHESTRA: Orchestra = Orchestra(
        instruments=[
            PiiInstrument(entities=["EMAIL_ADDRESS", "PERSON"], edit_mode="replace"),
            IdbacInstrument()  # example: identity-based access control
        ]
    )

Configuration reference (common keys):

Running (conceptual)

1. Ensure environment variables or a .env file are in place.
2. Launch the MCP Orchestra server process (example with uv):

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

3. The server will start configured MCP subprocesses, accept MCP connections, and apply Eunomia instruments to streamed text.

Available Resources

• GitHub repository: https://github.com/whataboutyou-ai/eunomia-MCP-server
• Eunomia framework (core): https://github.com/whataboutyou-ai/eunomia
• Eunomia docs: https://whataboutyou-ai.github.io/eunomia/
• Model Context Protocol: https://modelcontextprotocol.io/
• uv (astral) docs: https://docs.astral.sh/uv/

Note: links are provided for reference and further reading. Because this integration is deprecated, consult Eunomia docs for the latest recommended integration approaches.

Use Cases

1. PII Redaction in a Browser-based UI

   • Launch a web-browser MCP server as an external process.
   • Configure Eunomia with a PiiInstrument to replace or mask detected emails and names.
   • All user text that flows through the browser UI is inspected and transformed before being stored or sent to models.

2. Access-based Content Filtering for Multi-tenant Apps

   • Use IdbacInstrument to apply identity-based access control rules.
   • Route requests from different tenants to the same MCP server, with Eunomia enforcing per-tenant visibility rules.

3. Chaining Multiple MCP Services

   • Orchestrate several MCP servers (e.g., a UI server and a model-serving server).
   • Eunomia instruments enforce governance at the orchestra layer while each MCP process handles its domain responsibilities.

4. Local Development and Testing

   • Spin up MCP servers as subprocesses via the MCP_SERVERS configuration to simulate production routing and validate instruments against representative data.

Notes & Limitations

• Deprecated: This MCP Server integration does not work with the latest Eunomia changes. Do not rely on it for new production deployments.
• Use this repository as a learning reference for how Eunomia instruments can be applied to MCP-streamed content. Watch the GitHub project for the upcoming replacement integration.