Container-MCP

Eine sichere, containerbasierte Implementierung des Model Context Protocol (MCP) zur Ausführung von Tools im Auftrag großer Sprachmodelle.

Überblick

Container-MCP bietet eine Sandbox-Umgebung für die sichere Ausführung von Code, Befehlen, Dateizugriff und die Durchführung von Weboperationen, die von großen Sprachmodellen angefordert werden. Es implementiert das MCP-Protokoll, um diese Funktionen als Tools bereitzustellen, die von KI-Systemen sicher erkannt und aufgerufen werden können.

Die Architektur verwendet ein domänenspezifisches Managermuster mit mehrschichtiger Sicherheit, um sicherzustellen, dass Tools in isolierten Umgebungen mit entsprechenden Einschränkungen ausgeführt werden, wodurch das Hostsystem vor potenziell schädlichen Vorgängen geschützt wird.

Hauptmerkmale

Mehrschichtige Sicherheit
- Containerisolierung mit Podman/Docker
- AppArmor-Profile zur Zugriffsbeschränkung
- Firejail-Sandboxing für zusätzliche Isolierung
- Ressourcenbeschränkungen (CPU, Speicher, Ausführungszeit)
- Verhinderung der Pfaddurchquerung
- Zulässige Erweiterungsbeschränkungen
Implementierung des MCP-Protokolls
- Standardisierte Tool-Erkennung und -Ausführung
- Ressourcenmanagement
- Unterstützung für asynchrone Ausführung
Domänenspezifische Manager
- BashManager : Sichere Befehlsausführung
- PythonManager : Ausführung von Python-Code in einer Sandbox
- FileManager : Sichere Dateivorgänge
- WebManager : Sicheres Surfen und Scraping im Internet
Konfigurierbare Umgebung
- Umfangreiche Konfiguration über Umgebungsvariablen
- Unterstützung benutzerdefinierter Umgebungen
- Entwicklungs- und Produktionsmodi

Verfügbare Tools

Systembetrieb

`system_run_command`

Führt Bash-Befehle in einer sicheren Sandbox-Umgebung aus.

Parameter :
- command (Zeichenfolge, erforderlich): Der auszuführende Bash-Befehl
- working_dir (Zeichenfolge, optional): Arbeitsverzeichnis (wird in der Sandbox ignoriert)
Rückgaben :
- stdout (Zeichenfolge): Standardausgabe des Befehls
- stderr (Zeichenfolge): Standardfehler des Befehls
- exit_code (Ganzzahl): Befehls-Exitcode
- success (Boolesch): Ob der Befehl erfolgreich abgeschlossen wurde

{
  "stdout": "file1.txt\nfile2.txt\n",
  "stderr": "",
  "exit_code": 0,
  "success": true
}

`system_run_python`

Führt Python-Code in einer sicheren Sandbox-Umgebung aus.

Parameter :
- code (Zeichenfolge, erforderlich): Auszuführender Python-Code
- working_dir (Zeichenfolge, optional): Arbeitsverzeichnis (wird in der Sandbox ignoriert)
Rückgaben :
- output (Zeichenfolge): Ausgabe des Codes drucken
- error (Zeichenfolge): Fehlerausgabe vom Code
- result (beliebig): Optionaler Rückgabewert (verfügbar, wenn der Code die Variable _ setzt)
- success (Boolesch): Ob der Code erfolgreich ausgeführt wurde

{
  "output": "Hello, world!\n",
  "error": "",
  "result": 42,
  "success": true
}

`system_env_var`

Ruft Werte von Umgebungsvariablen ab.

Parameter :
- var_name (Zeichenfolge, optional): Spezifische abzurufende Variable
Rückgaben :
- variables (Objekt): Wörterbuch der Umgebungsvariablen
- requested_var (Zeichenfolge): Wert der angeforderten Variable (sofern var_name angegeben ist)

{
  "variables": {
    "MCP_PORT": "8000",
    "SANDBOX_ROOT": "/app/sandbox"
  },
  "requested_var": "8000"
}

Dateioperationen

`file_read`

Liest Dateiinhalte sicher.

Parameter :
- path (Zeichenfolge, erforderlich): Pfad zur Datei (relativ zum Sandbox-Stammverzeichnis)
- encoding (Zeichenfolge, optional): Dateikodierung (Standard: „utf-8“)
Rückgaben :
- content (Zeichenfolge): Dateiinhalt
- size (Ganzzahl): Dateigröße in Bytes
- modified (float): Zeitstempel der letzten Änderung
- success (Boolesch): Ob das Lesen erfolgreich war

{
  "content": "This is the content of the file.",
  "size": 31,
  "modified": 1673452800.0,
  "success": true
}

`file_write`

Schreibt Inhalte sicher in eine Datei.

Parameter :
- path (Zeichenfolge, erforderlich): Pfad zur Datei (relativ zum Sandbox-Stammverzeichnis)
- content (Zeichenfolge, erforderlich): Zu schreibender Inhalt
- encoding (Zeichenfolge, optional): Dateikodierung (Standard: „utf-8“)
Rückgaben :
- success (Boolesch): Ob der Schreibvorgang erfolgreich war
- path (Zeichenfolge): Pfad zur geschriebenen Datei

{
  "success": true,
  "path": "data/myfile.txt"
}

`file_list`

Listet den Inhalt eines Verzeichnisses sicher auf.

Parameter :
- path (Zeichenfolge, optional): Pfad zum Verzeichnis (Standard: "/")
- pattern (Zeichenfolge, optional): Glob-Muster zum Filtern von Dateien
Rückgaben :
- entries (Array): Liste der Verzeichniseinträge mit Metadaten
- path (Zeichenfolge): Der aufgelistete Verzeichnispfad
- success (Boolesch): Ob die Auflistung erfolgreich war

{
  "entries": [
    {
      "name": "file1.txt",
      "path": "file1.txt",
      "is_directory": false,
      "size": 1024,
      "modified": 1673452800.0
    },
    {
      "name": "data",
      "path": "data",
      "is_directory": true,
      "size": null,
      "modified": 1673452500.0
    }
  ],
  "path": "/",
  "success": true
}

`file_delete`

Löscht eine Datei sicher.

Parameter :
- path (Zeichenfolge, erforderlich): Pfad der zu löschenden Datei
Rückgaben :
- success (Boolean): Ob das Löschen erfolgreich war
- path (Zeichenfolge): Pfad zur gelöschten Datei

{
  "success": true,
  "path": "temp/old_file.txt"
}

`file_move`

Verschiebt oder benennt eine Datei sicher um.

Parameter :
- source (Zeichenfolge, erforderlich): Quelldateipfad
- destination (Zeichenfolge, erforderlich): Zieldateipfad
Rückgaben :
- success (Boolesch): Ob der Umzug erfolgreich war
- source (Zeichenfolge): Ursprünglicher Dateipfad
- destination (Zeichenfolge): Neuer Dateipfad

{
  "success": true,
  "source": "data/old_name.txt",
  "destination": "data/new_name.txt"
}

Web-Operationen

`web_search`

Verwendet eine Suchmaschine, um Informationen im Web zu finden.

Parameter :
- query (Zeichenfolge, erforderlich): Die zu suchende Abfrage
Rückgaben :
- results (Array): Liste der Suchergebnisse
- query (Zeichenfolge): Die ursprüngliche Abfrage

{
  "results": [
    {
      "title": "Search Result Title",
      "url": "https://example.com/page1",
      "snippet": "Text snippet from the search result..."
    }
  ],
  "query": "example search query"
}

`web_scrape`

Scrapt eine bestimmte URL und gibt den Inhalt zurück.

Parameter :
- url (Zeichenfolge, erforderlich): Die zu scrapende URL
- selector (Zeichenfolge, optional): CSS-Selektor zum Ansprechen bestimmter Inhalte
Rückgaben :
- content (Zeichenfolge): Gescrapter Inhalt
- url (Zeichenfolge): Die URL, die gescrapt wurde
- title (Zeichenfolge): Seitentitel
- success (Boolesch): Ob das Scraping erfolgreich war
- error (Zeichenfolge): Fehlermeldung, wenn Scraping fehlgeschlagen ist

{
  "content": "This is the content of the web page...",
  "url": "https://example.com/page",
  "title": "Example Page",
  "success": true,
  "error": null
}

`web_browse`

Durchsucht eine Website interaktiv mit Playwright.

Parameter :
- url (Zeichenfolge, erforderlich): Start-URL für die Browsersitzung
Rückgaben :
- content (Zeichenfolge): HTML-Inhalt der Seite
- url (Zeichenfolge): Die endgültige URL nach allen Weiterleitungen
- title (Zeichenfolge): Seitentitel
- success (Boolesch): Ob das Browsen erfolgreich war
- error (Zeichenfolge): Fehlermeldung, wenn das Durchsuchen fehlgeschlagen ist

{
  "content": "<!DOCTYPE html><html>...</html>",
  "url": "https://example.com/after_redirect",
  "title": "Example Page",
  "success": true,
  "error": null
}

Ausführungsumgebung

Container-MCP bietet isolierte Ausführungsumgebungen für verschiedene Arten von Vorgängen, jede mit ihren eigenen Sicherheitsmaßnahmen und Ressourcenbeschränkungen.

Containerumgebung

Der Hauptdienst Container-MCP wird in einem Container ausgeführt (mit Podman oder Docker) und stellt die erste Isolationsebene bereit:

Basis-Image : Ubuntu 24.04
Benutzer : Nicht-Root-Ubuntu-Benutzer
Python : 3.12
Netzwerk : Nur auf Localhost-Bindung beschränkt
Dateisystem : Volume-Mounts für Konfiguration, Daten und Protokolle
Sicherheit : AppArmor, Seccomp und Funktionsbeschränkungen

Bash-Ausführungsumgebung

Die Bash-Ausführungsumgebung ist mit mehreren Isolationsebenen konfiguriert:

Erlaubte Befehle : Beschränkt auf sichere Befehle, die in BASH_ALLOWED_COMMANDS konfiguriert sind
Firejail Sandbox : Prozessisolierung mit eingeschränktem Dateisystemzugriff
AppArmor-Profil : Feinkörnige Zugriffskontrolle
Ressourcenbeschränkungen :
- Ausführungs-Timeout (Standard: 30 s, Max: 120 s)
- Eingeschränkter Verzeichniszugriff nur auf Sandbox
Netzwerk : Kein Netzwerkzugriff
Dateisystem : Nur-Lese-Zugriff auf Daten, Lese-/Schreibzugriff auf Sandbox

Beispiele für zulässige Befehle:

ls, cat, grep, find, echo, pwd, mkdir, touch

Python-Ausführungsumgebung

Die Python-Ausführungsumgebung ist für die sichere Codeausführung konzipiert:

Python-Version : 3.12
Speicherlimit : Konfigurierbare Speicherobergrenze (Standard: 256 MB)
Ausführungs-Timeout : Konfigurierbares Zeitlimit (Standard: 30 s, max.: 120 s)
AppArmor-Profil : Beschränkt den Zugriff auf Systemressourcen
Firejail Sandbox : Prozessisolierung
Fähigkeiten : Alle Fähigkeiten gelöscht
Netzwerk : Kein Netzwerkzugriff
Verfügbare Bibliotheken : Nur Standardbibliothek
Ausgabeerfassung : stdout/stderr umgeleitet und bereinigt
Ressourcenkontrollen : CPU- und Speichergrenzen werden durchgesetzt

Dateisystemumgebung

Die Dateisystemumgebung steuert den Zugriff auf Dateien innerhalb der Sandbox:

Basisverzeichnis : Alle Vorgänge sind auf das Sandbox-Stammverzeichnis beschränkt
Pfadvalidierung : Alle Pfade werden normalisiert und auf Durchquerungsversuche überprüft
Größenbeschränkungen : Maximale Dateigröße wird erzwungen (Standard: 10 MB)
Erweiterungskontrolle : Nur zulässige Erweiterungen sind zulässig (Standard: txt, md, csv, json, py)
Berechtigungskontrolle : Erzwingung entsprechender Lese-/Schreibberechtigungen
Isolation : Kein Zugriff auf das Host-Dateisystem

Webumgebung

Die Webumgebung bietet kontrollierten Zugriff auf externe Ressourcen:

Domänenkontrolle : Optionale Whitelist zulässiger Domänen
Timeout-Steuerung : Konfigurierbare Timeouts für Vorgänge
Browsersteuerung : Headless-Browser über Playwright für vollständiges Rendering
Scraping-Steuerung : Einfaches Scraping über Anfragen/BeautifulSoup
Inhaltsbereinigung : Alle Inhalte werden analysiert und bereinigt
Netzwerkisolation : Separater Netzwerk-Namespace über Container

Architektur

Das Projekt folgt einer modularen Architektur:

container-mcp/
├── cmcp/                     # Main application code
│   ├── managers/             # Domain-specific managers
│   │   ├── bash_manager.py   # Secure bash execution
│   │   ├── python_manager.py # Secure python execution
│   │   ├── file_manager.py   # Secure file operations
│   │   └── web_manager.py    # Secure web operations
│   ├── utils/                # Utility functions
│   ├── config.py             # Configuration system
│   └── main.py               # MCP server setup
├── apparmor/                 # AppArmor profiles
├── config/                   # Configuration files
├── bin/                      # Build/run scripts
├── data/                     # Data directory
├── logs/                     # Log directory
├── sandbox/                  # Sandboxed execution space
│   ├── bash/                 # Bash sandbox
│   ├── python/               # Python sandbox
│   ├── files/                # File operation sandbox
│   └── browser/              # Web browser sandbox
├── temp/                     # Temporary storage
└── tests/                    # Test suites

Jeder Manager folgt konsistenten Designmustern:

.from_env() Klassenmethode für umgebungsbasierte Initialisierung
Asynchrone Ausführungsmethoden für nicht blockierende Vorgänge
Starke Eingabevalidierung und Fehlerbehandlung
Sicherheit steht bei allen Vorgängen an erster Stelle

Sicherheitsmaßnahmen

Container-MCP implementiert mehrere Sicherheitsebenen:

Containerisolierung : Verwendet Podman/Docker zur Containerisolierung
AppArmor-Profile : Feinkörnige Zugriffskontrolle für die Bash- und Python-Ausführung
Firejail Sandboxing : Zusätzliche Prozessisolierung
Ressourcenbeschränkungen : Speicher-, CPU- und Ausführungszeitbeschränkungen
Path Traversal Prevention : Validiert und normalisiert alle Dateipfade
Zulässige Erweiterungsbeschränkungen : Steuert, auf welche Dateitypen zugegriffen werden kann
Netzwerkbeschränkungen : Kontrolliert, auf welche Domänen zugegriffen werden kann
Geringste Berechtigungen : Komponenten werden mit den minimal erforderlichen Berechtigungen ausgeführt

Installation

Voraussetzungen

Linux-System mit Podman oder Docker
Python 3.12+
Firejail ( apt install firejail oder dnf install firejail )
AppArmor ( apt install apparmor apparmor-utils oder dnf install apparmor apparmor-utils )

Schnellstart

Der schnellste Einstieg erfolgt mit dem All-in-One-Skript:

git clone https://github.com/54rt1n/container-mcp.git
cd container-mcp
chmod +x bin/00-all-in-one.sh
./bin/00-all-in-one.sh

Schritt-für-Schritt-Installation

Sie können die Installationsschritte auch einzeln durchführen:

Initialisieren Sie das Projekt :
./bin/01-init.sh
Bauen Sie den Container :
./bin/02-build-container.sh
Richten Sie die Umgebung ein :
./bin/03-setup-environment.sh
Führen Sie den Container aus :
./bin/04-run-container.sh
Führen Sie Tests durch (optional):
./bin/05-run-tests.sh

Verwendung

Sobald der Container läuft, können Sie sich über eine beliebige MCP-Client-Implementierung mit ihm verbinden. Der Server ist unter http://localhost:8000 oder dem in Ihrer Konfiguration angegebenen Port erreichbar.

Wichtig: Bei der Konfiguration Ihres MCP-Clients müssen Sie die Endpunkt-URL auf http://127.0.0.1:<port>/sse setzen (wobei <port> standardmäßig 8000 oder der von Ihnen konfigurierte Port ist). Der Pfad /sse ist für die ordnungsgemäße Kommunikation serverseitig gesendeter Ereignisse erforderlich.

Beispiel eines Python-Clients

from mcp.client.sse import sse_client
from mcp import ClientSession
import asyncio

async def main():
    # Connect to the Container-MCP server
    # Note the /sse endpoint suffix required for SSE communication
    sse_url = "http://127.0.0.1:8000/sse"  # Or your configured port
    
    # Connect to the SSE endpoint
    async with sse_client(sse_url) as (read, write):
        async with ClientSession(read, write) as session:
            # Initialize the connection
            await session.initialize()
            
            # Discover available tools
            result = await session.list_tools()
            print(f"Available tools: {[tool.name for tool in result.tools]}")
            
            # Execute a Python script
            python_result = await session.execute_tool(
                "system_run_python",
                {"code": "print('Hello, world!')\nresult = 42\n_ = result"}
            )
            print(f"Python result: {python_result}")
            
            # Execute a bash command
            bash_result = await session.execute_tool(
                "system_run_command",
                {"command": "ls -la"}
            )
            print(f"Command output: {bash_result['stdout']}")

if __name__ == "__main__":
    asyncio.run(main())

Konfiguration

Container-MCP kann über Umgebungsvariablen konfiguriert werden, die in volume/config/custom.env festgelegt werden können:

Serverkonfiguration

# MCP Server Configuration
MCP_HOST=127.0.0.1
MCP_PORT=9001
DEBUG=true
LOG_LEVEL=INFO

Bash Manager-Konfiguration

# Bash Manager Configuration
BASH_ALLOWED_COMMANDS=ls,cat,grep,find,echo,pwd,mkdir,touch
BASH_TIMEOUT_DEFAULT=30
BASH_TIMEOUT_MAX=120

Python Manager-Konfiguration

# Python Manager Configuration
PYTHON_MEMORY_LIMIT=256
PYTHON_TIMEOUT_DEFAULT=30
PYTHON_TIMEOUT_MAX=120

Dateimanagerkonfiguration

# File Manager Configuration 
FILE_MAX_SIZE_MB=10
FILE_ALLOWED_EXTENSIONS=txt,md,csv,json,py

Web Manager-Konfiguration

# Web Manager Configuration
WEB_TIMEOUT_DEFAULT=30
WEB_ALLOWED_DOMAINS=*

Entwicklung

Einrichten einer Entwicklungsumgebung

Erstellen Sie eine virtuelle Python-Umgebung:
python3.12 -m venv .venv source .venv/bin/activate
Installieren Sie Abhängigkeiten:
pip install -r requirements-dev.txt
Installieren Sie das Paket im Entwicklungsmodus:
pip install -e .

Ausführen von Tests

# Run all tests
pytest

# Run only unit tests
pytest tests/unit

# Run only integration tests
pytest tests/integration

# Run with coverage report
pytest --cov=cmcp --cov-report=term --cov-report=html

Entwicklungsserver

So führen Sie den MCP-Server im Entwicklungsmodus aus:

python -m cmcp.main --test-mode

Lizenz

Dieses Projekt ist unter der Apache-Lizenz 2.0 lizenziert.

Autor

Martin Bukowski

This server cannot be installed

security - not tested

license - permissive license

quality - not tested

hybrid server

The server is able to function both locally and remotely, depending on the configuration or use case.

Eine sichere, containerbasierte Implementierung des Model Context Protocol (MCP), die Sandbox-Umgebungen für KI-Systeme bereitstellt, um sicher Code auszuführen, Befehle auszuführen, auf Dateien zuzugreifen und Weboperationen durchzuführen.

Related MCP Servers

Code Sandbox MCP
Automata-Labs-team
-
security
A
license
-
quality
An MCP server to create secure code sandbox environment for executing code within Docker containers.
Last updated -
69
Go
MIT License
MCP Server
GobinFan
-
security
F
license
-
quality
Implements the Model Context Protocol (MCP) to provide AI models with a standardized interface for connecting to external data sources and tools like file systems, databases, or APIs.
Last updated -
90
Python
MCP Local File Reader
sworddut
-
security
A
license
-
quality
A Model Context Protocol (MCP) server that allows AI models to safely access and interact with local file systems, enabling reading file contents, listing directories, and retrieving file metadata.
Last updated -
47
1
JavaScript
MIT License
MCP Shell Server
mkusaka
A
security
A
license
A
quality
A server that uses the Model Context Protocol (MCP) to allow AI agents to safely execute shell commands on a host system.
Last updated -
1
76
2
TypeScript
MIT License

View all related MCP servers