MCP für Dateisystem und Datenbanken
Was dieser Artikel über MCP für Dateisystem und Datenbanken behandelt
- Wie Du MCP-Tools für Dateisystem und Datenbanken baust.
- Wie Agenten Dateien lesen, schreiben und verwalten.
- Wie Agenten Datenbanken abfragen und manipulieren.
- Praxisbeispiele für Datei- und Datenbank-Operationen.
- Best Practices für Sicherheit und Berechtigungen.
Einleitung: MCP für Dateisystem und Datenbanken verständlich erklärt
MCP-Tools verbinden Agenten mit externen Systemen. Für Dateisystem: Der Agent kann Dateien lesen, schreiben, auflisten. Für Datenbanken: Der Agent kann abfragen, einfügen, aktualisieren. Mit Berechtigungen für Sicherheit.
Dieser Artikel richtet sich an Entwickler, die MCP-Tools für Dateisystem und Datenbanken bauen wollen. Grundlagen findest Du in MCP und MCP-Berechtigungen.
Warum brauche ich MCP für Dateisystem und Datenbanken?
Stell Dir vor, Dein Agent soll Dokumente verarbeiten: Er muss Dateien lesen (PDFs, Texte), analysieren und Ergebnisse speichern. Ohne MCP: Der Agent kann nicht auf Dateien zugreifen. Mit MCP: Er liest Dateien, verarbeitet sie, speichert Ergebnisse.
MCP für Dateisystem und Datenbanken kurz erklärt
MCP-Tool = Interface zwischen Agent und System. Dateisystem-Tool: read_file, write_file, list_files. Datenbank-Tool: query, insert, update. Mit Berechtigungen für Sicherheit.
Der Kerngedanke lautet: Agent + Tool = Zugriff auf externe Systeme.
Für wen ist dieser Artikel gedacht?
- Entwickler, die MCP-Tools bauen.
- Agenten-Bauer, die Datei/Datenbank-Zugriff brauchen.
- DevOps, die Agenten mit Systemen verbinden.
- Sicherheits-Bewusste, die Berechtigungen implementieren.
Wichtige Begriffe
- MCP - Model Context Protocol. Wann nützlich: für Tool-Integration.
- MCP-Berechtigungen - Zugriffskontrolle. Wann nützlich: für Sicherheit.
- Tool-Calling - Werkzeuge aufrufen. Wann nützlich: für Agenten.
- Ollama - Lokaler Modellserver. Wann nützlich: für Agenten.
Dateisystem-MCP-Tool
class FileSystemMCPTool:
"""MCP-Tool für Dateisystem"""
def __init__(self):
self.permissions = {
"read": True,
"write": True,
"delete": False,
"allowed_paths": ["/data", "/tmp", "/workspace"]
}
def get_tools(self):
"""Tool-Definitionen für MCP"""
return [
{
"name": "read_file",
"description": "Datei lesen",
"parameters": {
"type": "object",
"properties": {
"path": {"type": "string", "description": "Dateipfad"}
},
"required": ["path"]
}
},
{
"name": "write_file",
"description": "Datei schreiben",
"parameters": {
"type": "object",
"properties": {
"path": {"type": "string"},
"content": {"type": "string"}
},
"required": ["path", "content"]
}
},
{
"name": "list_files",
"description": "Dateien auflisten",
"parameters": {
"type": "object",
"properties": {
"directory": {"type": "string"}
},
"required": ["directory"]
}
}
]
def read_file(self, path):
"""Datei lesen"""
self.check_permission("read", path)
with open(path) as f:
return f.read()
def write_file(self, path, content):
"""Datei schreiben"""
self.check_permission("write", path)
with open(path, "w") as f:
f.write(content)
def list_files(self, directory):
"""Dateien auflisten"""
self.check_permission("read", directory)
import os
return os.listdir(directory)Datenbank-MCP-Tool
class DatabaseMCPTool:
"""MCP-Tool für Datenbank"""
def __init__(self, db_connection):
self.db = db_connection
self.permissions = {
"read": True,
"insert": True,
"update": False,
"delete": False,
"allowed_tables": ["users", "logs", "events"]
}
def get_tools(self):
"""Tool-Definitionen für MCP"""
return [
{
"name": "query_database",
"description": "Datenbank abfragen",
"parameters": {
"type": "object",
"properties": {
"table": {"type": "string"},
"filters": {"type": "object"}
},
"required": ["table"]
}
},
{
"name": "insert_data",
"description": "Daten einfügen",
"parameters": {
"type": "object",
"properties": {
"table": {"type": "string"},
"data": {"type": "object"}
},
"required": ["table", "data"]
}
}
]
def query(self, table, filters=None):
"""Datenbank abfragen"""
self.check_permission("read", table)
return self.db.query(table, filters)
def insert(self, table, data):
"""Daten einfügen"""
self.check_permission("insert", table)
return self.db.insert(table, data)Praxisbeispiel: Agent mit Dateisystem-MCP
# Agent nutzt Dateisystem-Tool
agent = Agent(
model="llama3.1",
tools=[FileSystemMCPTool()]
)
# Agent kann jetzt:
# - read_file("/data/document.txt")
# - write_file("/data/result.txt", "...")
# - list_files("/data")
# Beispiel-Task:
task = "Lies die Datei /data/report.txt und fasse sie zusammen."
# Agent: read_file → zusammenfassen → AntwortPraxisbeispiel: Agent mit Datenbank-MCP
# Agent nutzt Datenbank-Tool
agent = Agent(
model="llama3.1",
tools=[DatabaseMCPTool(db_connection)]
)
# Agent kann jetzt:
# - query_database("users", {"status": "active"})
# - insert_data("logs", {"event": "...", "timestamp": "..."})
# Beispiel-Task:
task = "Wie viele aktive Benutzer gibt es?"
# Agent: query_database → zählen → AntwortSicherheitshinweise
- Path-Restrictions: Für Dateisystem: Nur erlaubte Pfade. Siehe MCP-Berechtigungen.
- SQL-Injection: Für Datenbank: Parameterisierte Queries, keine String-Concatenation.
- Berechtigungen: Nur nötige Aktionen erlauben (read/write, kein delete).
- Audit: Alle Datei/Datenbank-Zugriffe loggen. Siehe Audit Logging.
Typische Stolpersteine
- Zu viele Berechtigungen: Agent sollte nicht alle Pfade/Tabellen zugreifen können.
- Keine Validierung: Pfade und Queries sollten validiert werden.
- SQL-Injection: Keine String-Concatenation für Queries. Parameterisierte Queries.
- Keine Fehlerbehandlung: Datei nicht gefunden, DB-Fehler → Fehlerbehandlung.
- Kein Rate-Limiting: Agent sollte nicht zu viele Requests senden.
Weiterführende Links
- MCP - Model Context Protocol.
- MCP-Berechtigungen - Zugriffskontrolle.
- Eigene MCP-Tools - Tools bauen.
- MCP-Sicherheit - Sicherheit.
- Tool-Berechtigungen - Berechtigungen.
Key Takeaways:
- MCP für Dateisystem: read_file, write_file, list_files mit Berechtigungen.
- MCP für Datenbanken: query, insert mit Tabellen-Restrictions.
- Path-Restrictions für Dateisystem, Table-Restrictions für Datenbank.
- Parameterisierte Queries gegen SQL-Injection.
- Audit-Log für alle Zugriffe.
FAQ
Was ist MCP für Dateisystem?
Ein MCP-Tool, das Agenten Zugriff auf das Dateisystem gibt: Dateien lesen, schreiben, auflisten. Mit Berechtigungen für erlaubte Pfade.
Was ist MCP für Datenbanken?
Ein MCP-Tool, das Agenten Zugriff auf Datenbanken gibt: Abfragen, einfügen, aktualisieren. Mit Berechtigungen für erlaubte Tabellen.
Ist das sicher?
Ja, mit Berechtigungen: Nur erlaubte Pfade/Tabellen, nur nötige Aktionen (read/write, kein delete), parameterisierte Queries, Audit-Log.
Wie setze ich Berechtigungen?
In jedem Tool: check_permission() vor jeder Aktion. Erlaubte Pfade für Dateisystem, erlaubte Tabellen für Datenbank, nur nötige Aktionen.
Wie verhindere ich SQL-Injection?
Parameterisierte Queries statt String-Concatenation. ORM oder Prepared Statements. Keine Benutzereingaben direkt in SQL.
Welche Tools gibt es?
Dateisystem: read_file, write_file, list_files, delete_file (optional). Datenbank: query, insert, update, delete (mit Berechtigungen).
Wie protokolliere ich Zugriffe?
Audit-Log: Jeder Datei/Datenbank-Zugriff wird geloggt (wer, was, wann, Ergebnis). Für Compliance und Debugging.
Quellen und weiterführende Literatur
- MCP - Model Context Protocol.
- SQL Injection Prevention - OWASP.