MCP para sistemas de archivos y bases de datos
Qué cubre este artículo sobre MCP para sistemas de archivos y bases de datos
- Cómo construir herramientas MCP para sistemas de archivos y bases de datos.
- Cómo los agentes leen, escriben y gestionan archivos.
- Cómo los agentes consultan y manipulan bases de datos.
- Ejemplos prácticos de operaciones con archivos y bases de datos.
- Mejores prácticas de seguridad y permisos.
Introducción: MCP para sistemas de archivos y bases de datos explicado
Las herramientas MCP conectan agentes con sistemas externos. Para el sistema de archivos, el agente puede leer, escribir y listar archivos. Para bases de datos, puede consultar, insertar y actualizar registros. Todo con control de permisos para garantizar la seguridad.
Este artículo está dirigido a desarrolladores que quieren construir herramientas MCP para sistemas de archivos y bases de datos. Encontrarás los fundamentos en MCP y Permisos de MCP.
¿Por qué necesito MCP para sistemas de archivos y bases de datos?
Imagina que tu agente debe procesar documentos: necesita leer archivos (PDFs, textos), analizarlos y guardar resultados. Sin MCP, el agente no puede acceder a los archivos. Con MCP, puede leerlos, procesarlos y almacenar los resultados.
MCP para sistemas de archivos y bases de datos en pocas palabras
Una herramienta MCP es una interfaz entre el agente y el sistema. Las herramientas del sistema de archivos incluyen read_file, write_file y list_files. Las herramientas de base de datos incluyen query, insert y update. Todo con permisos para seguridad.
La idea central es simple: Agente + Herramienta = Acceso a sistemas externos.
¿Para quién es este artículo?
- Desarrolladores que construyen herramientas MCP.
- Constructores de agentes que necesitan acceso a archivos y bases de datos.
- DevOps que conectan agentes con sistemas.
- Conscientes de seguridad que implementan permisos.
Términos clave
- MCP - Protocolo de Contexto de Modelo. Útil para: integración de herramientas.
- Permisos de MCP - Control de acceso. Útil para: seguridad.
- Llamada de herramientas - Invocación de herramientas. Útil para: agentes.
- Ollama - Servidor de modelos local. Útil para: agentes.
Herramienta MCP para sistemas de archivos
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)Herramienta MCP para bases de datos
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)Ejemplo práctico: Agente con MCP para sistemas de archivos
# 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 → AntwortEjemplo práctico: Agente con MCP para bases de datos
# 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 → AntwortConsideraciones de seguridad
- Restricciones de rutas: Para el sistema de archivos, solo permite rutas autorizadas. Consulta Permisos de MCP.
- Inyección SQL: Para bases de datos, usa consultas parametrizadas en lugar de concatenación de cadenas.
- Permisos: Solo permite las acciones necesarias (lectura/escritura, sin eliminación).
- Auditoría: Registra todos los accesos a archivos y bases de datos. Consulta Registro de auditoría.
Errores comunes
- Demasiados permisos: El agente no debería acceder a todas las rutas ni tablas.
- Falta de validación: Las rutas y consultas deben validarse.
- Inyección SQL: Nunca concatenes cadenas para construir consultas. Usa consultas parametrizadas.
- Sin manejo de errores: Archivo no encontrado, errores de BD. Implementa manejo de excepciones.
- Sin limitación de velocidad: El agente no debería enviar demasiadas solicitudes en poco tiempo.
Enlaces relacionados
- MCP - Protocolo de Contexto de Modelo.
- Permisos de MCP - Control de acceso.
- Herramientas MCP personalizadas - Construir herramientas.
- Seguridad de MCP - Seguridad.
- Permisos de herramientas - Permisos.
Puntos clave:
- MCP para sistemas de archivos: read_file, write_file, list_files con permisos.
- MCP para bases de datos: query, insert con restricciones de tablas.
- Restricciones de rutas para archivos, restricciones de tablas para bases de datos.
- Consultas parametrizadas contra inyección SQL.
- Registro de auditoría para todos los accesos.
FAQ
¿Qué es MCP para sistemas de archivos?
Una herramienta MCP que da a los agentes acceso al sistema de archivos: leer, escribir y listar archivos. Con permisos para rutas autorizadas.
¿Qué es MCP para bases de datos?
Una herramienta MCP que da a los agentes acceso a bases de datos: consultar, insertar y actualizar. Con permisos para tablas autorizadas.
¿Es seguro?
Sí, con permisos apropiados: solo rutas y tablas autorizadas, solo acciones necesarias (lectura/escritura, sin eliminación), consultas parametrizadas y registro de auditoría.
¿Cómo establezco los permisos?
En cada herramienta, usa check_permission() antes de cada acción. Define rutas permitidas para archivos, tablas permitidas para bases de datos y solo las acciones necesarias.
¿Cómo evito la inyección SQL?
Usa consultas parametrizadas en lugar de concatenación de cadenas. ORM o Prepared Statements. Nunca incluyas entrada de usuarios directamente en SQL.
¿Qué herramientas hay disponibles?
Sistema de archivos: read_file, write_file, list_files, delete_file (opcional). Base de datos: query, insert, update, delete (con permisos).
¿Cómo registro los accesos?
Mantén un registro de auditoría: cada acceso a archivos y bases de datos se registra (quién, qué, cuándo, resultado). Para cumplimiento y depuración.
Fuentes y referencias
- MCP - Protocolo de Contexto de Modelo.
- SQL Injection Prevention - OWASP.