Feature Engineering MCP Server

Ein MCP-Server (Model Context Protocol), der den vorhandenen LangGraph-Agenten ahutosh173/automated-feature-engineering als wiederverwendbare Tools bereitstellt.

Der ursprüngliche Agent akzeptiert eine CSV-Datei, ein Betrugs-/Modus-Operandi-Ziel, Schema-Metadaten, ID-Spalte und Label-Spalte und führt dann Folgendes aus:

1. analysiert das Modellierungsziel,

2. schlägt Kandidaten-Features vor,

3. generiert pandas-Code für das Feature-Engineering,

4. führt diesen Code aus und

5. schreibt eine Excel-Feature-Datei.

Dieses Projekt fügt diesem Workflow eine MCP-Schnittstelle hinzu.

Architektur

                 MCP Host / LLM Client
                         |
                         | MCP
                         v
              +-----------------------+
              | Feature Engineering   |
              | MCP Server            |
              +-----------+-----------+
                          |
              +-----------+-----------+
              |                       |
              v                       v
       Dataset profiling      Existing LangGraph
                              Feature Engineering Agent
                                      |
                       +--------------+--------------+
                       |              |              |
                    Analyze MO   Propose features  Generate code
                                                       |
                                                       v
                                                Execute features
                                                       |
                                                       v
                                                 Excel output

Related MCP server: skillsmcp

MCP-Tools

Wichtige Designentscheidung

Die MCP-Schicht ersetzt den vorhandenen Agenten nicht.

Sie ist ein Adapter um den vorhandenen Agenten, damit ein MCP-kompatibler Host den Feature-Engineering-Workflow als Tool erkennen und aufrufen kann.

Das ursprüngliche Repository ist:

https://github.com/ahutosh173/automated-feature-engineering

1. Voraussetzungen

• Python 3.10+

• Git

• Zugriff auf das ursprüngliche Feature-Engineering-Agenten-Repository

• Die vom ursprünglichen Agenten benötigte LLM-Konfiguration

Das MCP-Python-SDK erfordert derzeit Python 3.10+.

2. Beide Repositorys klonen

Empfohlenes Layout:

projects/
├── automated-feature-engineering/
└── feature-engineering-mcp/

Das ursprüngliche Repository klonen:

git clone https://github.com/ahutosh173/automated-feature-engineering.git

Dieses Repository klonen:

git clone <YOUR-MCP-REPO-URL>

3. Eine virtuelle Umgebung erstellen

Aus diesem Repository:

python -m venv .venv

Windows:

.venv\Scripts\activate

Linux/macOS:

source .venv/bin/activate

Abhängigkeiten installieren:

pip install -r requirements.txt

Die Abhängigkeiten des ursprünglichen Agenten installieren:

pip install -r ../automated-feature-engineering/requirements.txt

4. Den ursprünglichen Agenten konfigurieren

Das ursprüngliche Repository erwartet derzeit seine eigene .env-Konfiguration, einschließlich HF_TOKEN.

Konfigurieren Sie das Repository genau wie in seiner README beschrieben.

Committen Sie keine API-Schlüssel oder Tokens.

5. Diesen MCP-Server konfigurieren

Kopieren:

cp .env.example .env

Windows PowerShell:

Copy-Item .env.example .env

Festlegen:

FEATURE_ENGINEERING_REPO=../automated-feature-engineering

Wenn sich die beiden Repositorys woanders befinden, verwenden Sie einen absoluten Pfad.

Beispiel:

FEATURE_ENGINEERING_REPO=C:/projects/automated-feature-engineering

6. Den MCP-Server ausführen

Für die lokale stdio-Nutzung:

python server.py

Der Prozess wartet auf einen MCP-Client über stdin/stdout.

Für die Entwicklung mit dem MCP Inspector:

mcp dev server.py

Das offizielle MCP-Python-SDK bietet den Inspector-Entwicklungsworkflow und unterstützt die direkte Definition von Tools aus typisierten Python-Funktionen.

7. Ohne externen MCP-Host testen

Ausführen:

pytest -q

Die Tests verwenden die In-Memory-Verbindung des MCP-Python-Clients und testen daher die MCP-Tooldefinitionen, ohne einen Subprozess zu starten.

Beispiel: einen Datensatz profilieren

Ein MCP-Client kann Folgendes aufrufen:

{
  "name": "profile_dataset",
  "arguments": {
    "csv_path": "../automated-feature-engineering/data/train.csv"
  }
}

Beispielantwort:

{
  "success": true,
  "rows": 10000,
  "columns": 25,
  "columns_info": [
    {
      "name": "amount",
      "dtype": "float64",
      "missing": 0,
      "missing_pct": 0.0,
      "unique": 9000
    }
  ]
}

Beispiel: den Agenten ausführen

{
  "name": "run_feature_engineering",
  "arguments": {
    "csv_path": "../automated-feature-engineering/data/train.csv",
    "mo_name": "Fraud Detection",
    "mo_description": "Identify fraudulent transactions based on account behavior",
    "data_schema": [
      {
        "name": "txn_id",
        "dtype": "object",
        "description": "Transaction ID"
      },
      {
        "name": "amount",
        "dtype": "float64",
        "description": "Transaction amount"
      }
    ],
    "id_column": "txn_id",
    "label_column": "fraud"
  }
}

Warum MCP hier nützlich ist

Ohne MCP ist der Feature-Engineering-Workflow in erster Linie eine Python-Anwendung.

Mit MCP kann ein MCP-kompatibler Host die Feature-Engineering-Tools erkennen und entscheiden, wann er sie aufruft.

Zum Beispiel:

User:
"Analyze my fraud dataset and create account-level features."

LLM:
  -> profile_dataset
  -> run_feature_engineering
  -> inspect result
  -> explain generated features

Sicherheitshinweis

Der ursprüngliche Agent generiert mit einem LLM Python-Code und führt ihn mit exec() aus. Das ist ein risikoreicher Vorgang, wenn nicht vertrauenswürdige Modellausgaben oder nicht vertrauenswürdige Benutzer den Server erreichen können.

Für die Produktion:

• den Agenten in einem isolierten Container ausführen,

• ein eingeschränktes Dateisystem verwenden,

• generierten Code validieren,

• Importe einschränken,

• Eingabe-/Ausgabepfade einschränken,

• Ressourcen- und CPU/Zeitlimits verwenden,

• keinen beliebigen Dateisystemzugriff bereitstellen,

• Authentifizierung/Autorisierung vor der Remote-Bereitstellung hinzufügen.

Dieses Repository erhebt bewusst nicht den Anspruch, dass die vorhandene Ausführung von generiertem Code produktionssicher ist.

Vorgeschlagene nächste Erweiterungen

1. Ein Tool zur Feature-Bewertung hinzufügen.

2. Einen Modellleistungsvergleich hinzufügen.

3. Feature-Lineage-Metadaten hinzufügen.

4. Genehmigung/Überprüfung hinzufügen, bevor generierter Code ausgeführt wird.

5. Streamable-HTTP-Bereitstellung hinzufügen.

6. Authentifizierung hinzufügen.

7. LangGraph-Checkpoint-/Sitzungs-IDs hinzufügen, anstelle der festen Thread-ID, die der ursprüngliche Workflow verwendet.