MongoDB Lens

Servidor MCP completo para la base de datos MongoDB.

GitHub
208
Prueba este MCPPatrocinado

Documentación

MongoDB Lens

License Docker Hub Version NPM Version Buy Me a Coffee

MongoDB Lens es un servidor local de Model Context Protocol (MCP) con acceso completo a bases de datos MongoDB mediante lenguaje natural a través de LLMs para realizar consultas, ejecutar agregaciones, optimizar el rendimiento y más.

Contenido

Inicio rápido

Características

Herramientas

Recursos

Indicaciones

  • aggregation-builder: Creación paso a paso de pipelines de agregación
  • backup-strategy: Recomendaciones personalizadas de respaldo y recuperación
  • data-modeling: Asesoramiento experto sobre diseño de esquemas MongoDB para casos de uso específicos
  • database-health-check: Evaluación integral de salud de la base de datos y recomendaciones
  • index-recommendation: Obtenga sugerencias personalizadas de índices basadas en patrones de consulta
  • migration-guide: Planes de migración de versiones de MongoDB paso a paso
  • mongo-shell: Generar comandos de shell de MongoDB con explicaciones
  • multi-tenant-design: Diseñar arquitectura de base de datos multi-tenant en MongoDB
  • query-builder: Guía interactiva para construir consultas MongoDB
  • query-optimizer: Recomendaciones de optimización para consultas lentas
  • schema-analysis: Análisis detallado de esquema de colección con recomendaciones
  • schema-versioning: Gestionar la evolución de esquemas en aplicaciones MongoDB
  • security-audit: Análisis de seguridad de la base de datos y recomendaciones de mejora
  • sql-to-mongodb: Convertir consultas SQL a pipelines de agregación MongoDB

Otras Características

Otras Características: Resumen

MongoDB Lens incluye numerosas otras características:

  • Archivo de Configuración: Configuración personalizada mediante ~/.mongodb-lens.[jsonc|json]
  • Anulaciones de Variables de Entorno: Anular ajustes de configuración mediante process.env.CONFIG_*
  • Sistema de Confirmación: Verificación en dos pasos para operaciones destructivas
  • Múltiples Conexiones: Definir y cambiar entre alias de URI nombrados
  • Desactivación de Componentes: Desactivar selectivamente herramientas, indicaciones o recursos
  • Resiliencia de Conexión: Reconexión automática con retroceso exponencial
  • Salvaguardas de Consulta: Límites configurables y protecciones de rendimiento
  • Manejo de Errores: Códigos y mensajes de error JSONRPC completos
  • Inferencia de Esquema: Análisis de esquema eficiente con muestreo inteligente
  • Protección de Credenciales: Ofuscación de contraseñas en cadenas de conexión en registros
  • Gestión de Memoria: Monitoreo y limpieza automáticos para operaciones grandes
  • Caché Inteligente: Caché optimizada para esquemas, índices, campos y colecciones
  • Compatibilidad Retroactiva: Soporte para versiones modernas y antiguas de MongoDB

Otras Características: Metadatos de Nueva Base de Datos

MongoDB Lens inserta una colección metadata en cada base de datos que crea.

Esta colección metadata almacena un único documento que contiene información contextual que sirve como registro permanente del origen de la base de datos, asegurando al mismo tiempo que la base de datos nueva y por lo demás vacía persista en el sistema de almacenamiento de MongoDB.

Documento de metadatos de ejemplo 
{
    "_id" : ObjectId("67d5284463788ec38aecee14"),
    "created" : {
        "timestamp" : ISODate("2025-03-15T07:12:04.705Z"),
        "tool" : "MongoDB Lens v5.0.7",
        "user" : "anonymous"
    },
    "mongodb" : {
        "version" : "3.6.23",
        "connectionInfo" : {
            "host" : "unknown",
            "readPreference" : "primary"
        }
    },
    "database" : {
        "name" : "example_database",
        "description" : "Created via MongoDB Lens"
    },
    "system" : {
        "hostname" : "unknown",
        "platform" : "darwin",
        "nodeVersion" : "v22.14.0"
    },
    "lens" : {
        "version" : "5.0.7",
        "startTimestamp" : ISODate("2025-03-15T07:10:06.084Z")
    }
}

Una vez que haya agregado sus propias colecciones a su nueva base de datos, puede eliminar de manera segura la colección metadata mediante la herramienta drop-collection:

  • "Eliminar la colección de metadatos de la nueva base de datos"
    ➥ Usa la herramienta drop-collection (con confirmación)

Instalación

MongoDB Lens se puede instalar y ejecutar de varias maneras:

Instalación: NPX

[!NOTE]
NPX requiere Node.js instalado y ejecutándose en su sistema (sugerencia: use Volta).

La forma más fácil de ejecutar MongoDB Lens es usando NPX.

Primero, asegúrese de que Node.js esté instalado:

node --version # Ideally >= v22.x but MongoDB Lens is >= v18.x compatible

Luego, ejecute MongoDB Lens mediante NPX:

# Using default connection string mongodb://localhost:27017
npx -y mongodb-lens

# Using custom connection string
npx -y mongodb-lens mongodb://your-connection-string

# Using "@latest" to keep the package up-to-date
npx -y mongodb-lens@latest

[!TIP]
Si encuentra errores de permisos con npx, intente ejecutar npx clear-npx-cache antes de ejecutar npx -y mongodb-lens (esto limpia la caché y vuelve a descargar el paquete).

Instalación: Docker Hub

[!NOTE]
Docker Hub requiere Docker instalado y ejecutándose en su sistema.

Primero, asegúrese de que Docker esté instalado:

docker --version # Ideally >= v27.x

Luego, ejecute MongoDB Lens mediante Docker Hub:

# Using default connection string mongodb://localhost:27017
docker run --rm -i --network=host furey/mongodb-lens

# Using custom connection string
docker run --rm -i --network=host furey/mongodb-lens mongodb://your-connection-string

# Using "--pull" to keep the Docker image up-to-date
docker run --rm -i --network=host --pull=always furey/mongodb-lens

Instalación: Node.js desde el Código Fuente

[!NOTE]
Node.js desde el código fuente requiere Node.js instalado y ejecutándose en su sistema (sugerencia: use Volta).

  1. Clone el repositorio de MongoDB Lens:
    git clone https://github.com/furey/mongodb-lens.git
  2. Navegue al directorio del repositorio clonado:
    cd /path/to/mongodb-lens
  3. Asegúrese de que Node.js esté instalado:
    node --version # Ideally >= v22.x but MongoDB Lens is >= v18.x compatible
  4. Instale las dependencias de Node.js:
    npm ci
  5. Inicie el servidor:
    # Using default connection string mongodb://localhost:27017
node mongodb-lens.js

# Using custom connection string
node mongodb-lens.js mongodb://your-connection-string

Instalación: Docker desde el Código Fuente

[!NOTE]
Docker desde el código fuente requiere Docker instalado y ejecutándose en su sistema.

  1. Clone el repositorio de MongoDB Lens:
    git clone https://github.com/furey/mongodb-lens.git
  2. Navegue al directorio del repositorio clonado:
    cd /path/to/mongodb-lens
  3. Asegúrese de que Docker esté instalado:
    docker --version # Ideally >= v27.x
  4. Construya la imagen de Docker:
    docker build -t mongodb-lens .
  5. Ejecute el contenedor:
    # Using default connection string mongodb://localhost:27017
docker run --rm -i --network=host mongodb-lens

# Using custom connection string
docker run --rm -i --network=host mongodb-lens mongodb://your-connection-string

Verificación de la Instalación

Para verificar la instalación, pegue y ejecute el siguiente mensaje JSONRPC en el stdio del servidor:

{"method":"resources/read","params":{"uri":"mongodb://databases"},"jsonrpc":"2.0","id":1}

El servidor debería responder con una lista de bases de datos en su instancia de MongoDB, por ejemplo:

{"result":{"contents":[{"uri":"mongodb://databases","text":"Databases (12):\n- admin (180.00 KB)\n- config (108.00 KB)\n- local (40.00 KB)\n- sample_airbnb (51.88 MB)\n- sample_analytics (9.46 MB)\n- sample_geospatial (980.00 KB)\n- sample_guides (40.00 KB)\n- sample_mflix (108.90 MB)\n- sample_restaurants (7.73 MB)\n- sample_supplies (968.00 KB)\n- sample_training (40.85 MB)\n- sample_weatherdata (2.69 MB)"}]},"jsonrpc":"2.0","id":1}

MongoDB Lens ahora está instalado y listo para aceptar solicitudes MCP.

Instalación: Versiones Antiguas de MongoDB

Si se conecta a una instancia de MongoDB con una versión < 4.0, el controlador Node.js de MongoDB utilizado por la última versión de MongoDB Lens no será compatible. Específicamente, las versiones 4.0.0 y superiores del controlador Node.js de MongoDB requieren MongoDB versión 4.0 o superior.

Para usar MongoDB Lens con instancias de MongoDB más antiguas, debe usar una versión del controlador Node.js de MongoDB de la serie 3.x (por ejemplo, 3.7.4, que es compatible con MongoDB 3.6).

Versiones Antiguas de MongoDB: Ejecución desde el Código Fuente

  1. Clone el repositorio de MongoDB Lens:
    git clone https://github.com/furey/mongodb-lens.git
  2. Navegue al directorio del repositorio clonado:
    cd /path/to/mongodb-lens
  3. Modifique package.json:
    "dependencies": {
  ...
-  "mongodb": "^6.15.0",  // Or whatever newer version is listed
+  "mongodb": "^3.7.4",   // Or whatever 3.x version is compatible with your older MongoDB instance
  ...
}
  4. Instale las dependencias de Node.js:
    npm install
  5. Inicie MongoDB Lens:
    node mongodb-lens.js mongodb://older-mongodb-instance

Esto utilizará la versión anterior del controlador compatible con su instancia de MongoDB.

[!NOTE]
También es posible que deba revertir este commit para volver a agregar las opciones de configuración de MongoDB useNewUrlParser y useUnifiedTopology.

Versiones Antiguas de MongoDB: Uso de NPX o Docker

Si prefiere usar NPX o Docker, deberá usar una versión anterior de MongoDB Lens que se haya publicado con un controlador compatible.

Por ejemplo, MongoDB Lens 8.3.0 usa el controlador Node.js de MongoDB 3.7.4 (consulte: package-lock.json).

Para ejecutar una versión anterior de MongoDB Lens usando NPX, especifique la etiqueta de versión:

npx -y mongodb-lens@8.3.0

De manera similar para Docker:

docker run --rm -i --network=host furey/mongodb-lens:8.3.0

Configuración

Configuración: Cadena de conexión de MongoDB

El servidor acepta una cadena de conexión de MongoDB como su único argumento.

Ejemplo de uso con NPX:

npx -y mongodb-lens@latest mongodb://your-connection-string

Las cadenas de conexión de MongoDB tienen el siguiente formato:

mongodb://[username:password@]host[:port][/database][?options]

Ejemplos de cadenas de conexión:

  • Conexión local:
    mongodb://localhost:27017
  • Conexión a mydatabase con credenciales de la base de datos admin:
    mongodb://username:password@hostname:27017/mydatabase?authSource=admin
  • Conexión a mydatabase con varias otras opciones:
    mongodb://hostname:27017/mydatabase?retryWrites=true&w=majority

Si no se proporciona una cadena de conexión, el servidor intentará conectarse mediante una conexión local.

Configuración: Archivo de configuración

MongoDB Lens admite una amplia personalización mediante un archivo de configuración JSON.

[!NOTE]
El archivo de configuración es opcional. MongoDB Lens se ejecutará con la configuración predeterminada si no se proporciona ningún archivo de configuración.

[!TIP]
Solo necesita incluir en el archivo de configuración los ajustes que desea personalizar. MongoDB Lens usará la configuración predeterminada para cualquier valor omitido.

[!TIP]
MongoDB Lens admite formatos de archivo de configuración .json y .jsonc (JSON con comentarios).

Ejemplo de archivo de configuración 
{
  "mongoUri": "mongodb://localhost:27017",         // Default MongoDB connection string or object of alias-URI pairs
  "connectionOptions": {
    "maxPoolSize": 20,                             // Maximum number of connections in the pool
    "retryWrites": false,                          // Whether to retry write operations
    "connectTimeoutMS": 30000,                     // Connection timeout in milliseconds
    "socketTimeoutMS": 360000,                     // Socket timeout in milliseconds
    "heartbeatFrequencyMS": 10000,                 // How often to ping servers for status
    "serverSelectionTimeoutMS": 30000              // Timeout for server selection
  },
  "defaultDbName": "admin",                        // Default database if not specified in URI
  "connection": {
    "maxRetries": 5,                               // Maximum number of initial connection attempts
    "maxRetryDelayMs": 30000,                      // Maximum delay between retries
    "reconnectionRetries": 10,                     // Maximum reconnection attempts if connection lost
    "initialRetryDelayMs": 1000                    // Initial delay between retries
  },
  "disabled": {
    "tools": [],                                   // Array of tools to disable or true to disable all
    "prompts": [],                                 // Array of prompts to disable or true to disable all
    "resources": []                                // Array of resources to disable or true to disable all
  },
  "enabled": {
    "tools": true,                                 // Array of tools to enable or true to enable all
    "prompts": true,                               // Array of prompts to enable or true to enable all
    "resources": true                              // Array of resources to enable or true to enable all
  },
  "cacheTTL": {
    "stats": 15000,                                // Stats cache lifetime in milliseconds
    "fields": 30000,                               // Fields cache lifetime in milliseconds
    "schemas": 60000,                              // Schema cache lifetime in milliseconds
    "indexes": 120000,                             // Index cache lifetime in milliseconds
    "collections": 30000,                          // Collections list cache lifetime in milliseconds
    "serverStatus": 20000                          // Server status cache lifetime in milliseconds
  },
  "enabledCaches": [                               // List of caches to enable
    "stats",                                       // Statistics cache
    "fields",                                      // Collection fields cache
    "schemas",                                     // Collection schemas cache
    "indexes",                                     // Collection indexes cache
    "collections",                                 // Database collections cache
    "serverStatus"                                 // MongoDB server status cache
  ],
  "memory": {
    "enableGC": true,                              // Whether to enable garbage collection
    "warningThresholdMB": 1500,                    // Memory threshold for warnings
    "criticalThresholdMB": 2000                    // Memory threshold for cache clearing
  },
  "logLevel": "info",                              // Log level (info or verbose)
  "disableDestructiveOperationTokens": false,      // Whether to skip confirmation for destructive ops
  "watchdogIntervalMs": 30000,                     // Interval for connection monitoring
  "defaults": {
    "slowMs": 100,                                 // Threshold for slow query detection
    "queryLimit": 10,                              // Default limit for query results
    "allowDiskUse": true,                          // Allow operations to use disk for large datasets
    "schemaSampleSize": 100,                       // Sample size for schema inference
    "aggregationBatchSize": 50                     // Batch size for aggregation operations
  },
  "security": {
    "tokenLength": 4,                              // Length of confirmation tokens
    "tokenExpirationMinutes": 5,                   // Expiration time for tokens
    "strictDatabaseNameValidation": true           // Enforce strict database name validation
  },
  "tools": {
    "transaction": {
      "readConcern": "snapshot",                   // Read concern level for transactions
      "writeConcern": {
        "w": "majority"                            // Write concern for transactions
      }
    },
    "bulkOperations": {
      "ordered": true                              // Whether bulk operations execute in order
    },
    "export": {
      "defaultLimit": -1,                          // Default limit for exports (-1 = no limit)
      "defaultFormat": "json"                      // Default export format (json or csv)
    },
    "watchChanges": {
      "maxDurationSeconds": 60,                    // Maximum duration for change streams
      "defaultDurationSeconds": 10                 // Default duration for change streams
    },
    "queryAnalysis": {
      "defaultDurationSeconds": 10                 // Default duration for query analysis
    }
  }
}

De forma predeterminada, MongoDB Lens busca el archivo de configuración en:

  • ~/.mongodb-lens.jsonc primero, y luego recurre a
  • ~/.mongodb-lens.json si el primero no existe

Para personalizar la ruta del archivo de configuración, establezca la variable de entorno CONFIG_PATH en la ruta de archivo deseada.

Ejemplo de uso con NPX:

CONFIG_PATH='/path/to/config.json' npx -y mongodb-lens@latest

Ejemplo de uso con Docker Hub:

docker run --rm -i --network=host --pull=always -v /path/to/config.json:/root/.mongodb-lens.json furey/mongodb-lens

Configuración: Generación del archivo de configuración

Puede generar un archivo de configuración automáticamente usando el script config:create:

# NPX Usage (recommended)
npx -y mongodb-lens@latest config:create

# Node.js Usage
npm run config:create

# Force overwrite existing files
npx -y mongodb-lens@latest config:create -- --force
npm run config:create -- --force

Este script extrae el archivo de configuración de ejemplo anterior y lo guarda en: ~/.mongodb-lens.jsonc

Generación del archivo de configuración: Ruta personalizada

Puede especificar una ubicación de salida personalizada usando la variable de entorno CONFIG_PATH.

  • Si CONFIG_PATH no tiene extensión de archivo, se trata como un directorio y se agrega .mongodb-lens.jsonc
  • Si CONFIG_PATH termina con .json (no .jsonc), se eliminan los comentarios del archivo generado

Ejemplo de uso con NPX:

# With custom path
CONFIG_PATH=/path/to/config.jsonc npx -y mongodb-lens@latest config:create

# Save to directory (will append .mongodb-lens.jsonc to the path)
CONFIG_PATH=/path/to/directory npx -y mongodb-lens@latest config:create

# Save as JSON instead of JSONC
CONFIG_PATH=/path/to/config.json npx -y mongodb-lens@latest config:create

Ejemplo de uso con Node.js:

# With custom path
CONFIG_PATH=/path/to/config.jsonc node mongodb-lens.js config:create

# Save to directory (will append .mongodb-lens.jsonc to the path)
CONFIG_PATH=/path/to/directory node mongodb-lens.js config:create

# Save as JSON instead of JSONC
CONFIG_PATH=/path/to/config.json node mongodb-lens.js config:create

Configuración: Múltiples conexiones de MongoDB

MongoDB Lens admite múltiples URI de MongoDB con alias en su archivo de configuración, lo que le permite cambiar fácilmente entre diferentes instancias de MongoDB usando nombres simples.

Para configurar múltiples conexiones, establezca el ajuste de configuración mongoUri en un objeto con pares alias-URI:

{
  "mongoUri": {
    "main": "mongodb://localhost:27017",
    "backup": "mongodb://localhost:27018",
    "atlas": "mongodb+srv://username:password@cluster.mongodb.net/mydb"
  }
}

Con esta configuración:

  • La primera URI de la lista (por ejemplo, main) se convierte en la conexión predeterminada al inicio
  • Puede cambiar de conexión usando lenguaje natural: "Connect to backup" o "Connect to atlas"
  • La sintaxis original sigue funcionando: "Connect to mongodb://localhost:27018"
  • La herramienta list-connections muestra todos los alias de conexión disponibles

[!NOTE]
Al usar el argumento de línea de comandos para especificar una conexión, puede usar una URI completa de MongoDB o un alias definido en su archivo de configuración.

[!TIP]
Para agregar alias de conexión en tiempo de ejecución, use la herramienta add-connection-alias.

Configuración: Anulaciones de variables de entorno

MongoDB Lens admite anulaciones de variables de entorno para los ajustes de configuración.

Las variables de entorno tienen prioridad sobre los ajustes del archivo de configuración.

Las variables de entorno de configuración siguen el patrón de nomenclatura:

CONFIG_[SETTING PATH, SNAKE CASED, UPPERCASED]

Ejemplos de anulaciones:

Ajuste de configuraciónAnulación de variable de entorno
mongoUriCONFIG_MONGO_URI
logLevelCONFIG_LOG_LEVEL
defaultDbNameCONFIG_DEFAULT_DB_NAME
defaults.queryLimitCONFIG_DEFAULTS_QUERY_LIMIT
tools.export.defaultFormatCONFIG_TOOLS_EXPORT_DEFAULT_FORMAT
connectionOptions.maxPoolSizeCONFIG_CONNECTION_OPTIONS_MAX_POOL_SIZE
connection.reconnectionRetriesCONFIG_CONNECTION_RECONNECTION_RETRIES

Para los valores de las variables de entorno:

  • Para ajustes booleanos, use los valores de cadena 'true' o 'false'.
  • Para ajustes numéricos, use representaciones de cadena.
  • Para objetos anidados o matrices, use cadenas JSON.

Ejemplo de uso con NPX:

CONFIG_DEFAULTS_QUERY_LIMIT='25' npx -y mongodb-lens@latest

Ejemplo de uso con Docker Hub:

docker run --rm -i --network=host --pull=always -e CONFIG_DEFAULTS_QUERY_LIMIT='25' furey/mongodb-lens

Configuración: Variables de entorno multiplataforma

Para un uso consistente de variables de entorno en Windows, macOS y Linux, considere usar cross-env:

  1. Instale cross-env globalmente:
    # Using NPM
npm install -g cross-env

# Using Volta (see: https://volta.sh)
volta install cross-env
  2. Anteponga cualquier variable de entorno NPX o Node.js en los ejemplos de este documento:
    # Example NPX usage with cross-env
cross-env CONFIG_DEFAULTS_QUERY_LIMIT='25' npx -y mongodb-lens@latest

# Example Node.js usage with cross-env
cross-env CONFIG_DEFAULTS_QUERY_LIMIT='25' node mongodb-lens.js

Configuración del cliente

Configuración del cliente: Claude Desktop

Para usar MongoDB Lens con Claude Desktop:

  1. Instale Claude Desktop
  2. Abra claude_desktop_config.json (créelo si no existe):
    • macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
    • Windows: %APPDATA%\Claude\claude_desktop_config.json
  3. Agregue la configuración del servidor MongoDB Lens según las opciones de configuración
  4. Reinicie Claude Desktop
  5. Inicie una conversación con Claude sobre sus datos de MongoDB

Opciones de configuración de Claude Desktop

Para cada opción:

  • Reemplace mongodb://your-connection-string con su cadena de conexión de MongoDB u omítala para usar el valor predeterminado mongodb://localhost:27017.
  • Para usar un archivo de configuración personalizado, establezca la variable de entorno CONFIG_PATH.
  • Para incluir variables de entorno:
    • Para NPX o Node.js, agregue "env": {} con pares clave-valor, por ejemplo:
      "command": "/path/to/npx",
"args": [
  "-y",
  "mongodb-lens@latest",
  "mongodb://your-connection-string"
],
"env": {
  "CONFIG_LOG_LEVEL": "verbose"
}
    • Para Docker, agregue banderas -e, por ejemplo:
      "command": "docker",
"args": [
  "run", "--rm", "-i",
  "--network=host",
  "--pull=always",
  "-e", "CONFIG_LOG_LEVEL=verbose",
  "furey/mongodb-lens",
  "mongodb://your-connection-string"
]
Opción 1: NPX (Recomendado)
{
  "mcpServers": {
    "mongodb-lens": {
      "command": "/path/to/npx",
      "args": [
        "-y",
        "mongodb-lens@latest",
        "mongodb://your-connection-string"
      ]
    }
  }
}
Opción 2: Imagen de Docker Hub
{
  "mcpServers": {
    "mongodb-lens": {
      "command": "docker",
      "args": [
        "run", "--rm", "-i",
        "--network=host",
        "--pull=always",
        "furey/mongodb-lens",
        "mongodb://your-connection-string"
      ]
    }
  }
}
Opción 3: Instalación local de Node.js
{
  "mcpServers": {
    "mongodb-lens": {
      "command": "/path/to/node",
      "args": [
        "/path/to/mongodb-lens.js",
        "mongodb://your-connection-string"
      ]
    }
  }
}
Opción 4: Imagen local de Docker
{
  "mcpServers": {
    "mongodb-lens": {
      "command": "docker",
      "args": [
        "run", "--rm", "-i",
        "--network=host",
        "mongodb-lens",
        "mongodb://your-connection-string"
      ]
    }
  }
}

Configuración del cliente: MCP Inspector

MCP Inspector es una herramienta diseñada para probar y depurar servidores MCP.

[!NOTE]
MCP Inspector inicia un servidor proxy en el puerto 3000 y un cliente web en el puerto 5173.

Ejemplo de uso con NPX:

  1. Ejecute MCP Inspector:
    # Using default connection string mongodb://localhost:27017
npx -y @modelcontextprotocol/inspector npx -y mongodb-lens@latest

# Using custom connection string
npx -y @modelcontextprotocol/inspector npx -y mongodb-lens@latest mongodb://your-connection-string

# Using custom ports
SERVER_PORT=1234 CLIENT_PORT=5678 npx -y @modelcontextprotocol/inspector npx -y mongodb-lens@latest
  2. Abra MCP Inspector: http://localhost:5173

MCP Inspector debería admitir toda la gama de capacidades de MongoDB Lens, incluido el autocompletado de nombres de colecciones y campos de consulta.

Para más información, consulte: MCP Inspector

Configuración del cliente: Otros clientes MCP

MongoDB Lens debería ser utilizable con cualquier cliente compatible con MCP.

Para más información, consulte: Documentación de MCP: Ejemplos de clientes

Protección de datos

Para proteger sus datos mientras usa MongoDB Lens, considere lo siguiente:

Protección de datos: Cuentas de usuario de solo lectura

Al conectar MongoDB Lens a su base de datos, los permisos otorgados al usuario en la cadena de conexión de MongoDB determinan qué acciones se pueden realizar. Cuando el caso de uso lo permita, un usuario de solo lectura puede evitar escrituras o eliminaciones no intencionadas, asegurando que MongoDB Lens pueda consultar datos pero no modificarlos.

Para configurar esto, cree un usuario con el rol read limitado a la(s) base(s) de datos que está utilizando. En el shell de MongoDB, ejecutaría algo como:

use admin

db.createUser({
  user: 'readonly',
  pwd: 'eXaMpLePaSsWoRd',
  roles: [{ role: 'read', db: 'mydatabase' }]
})

Luego, aplique esas credenciales a su cadena de conexión de MongoDB:

mongodb://readonly:eXaMpLePaSsWoRd@localhost:27017/mydatabase

Usar credenciales de solo lectura es una forma simple pero efectiva de hacer cumplir los límites de seguridad, especialmente cuando está explorando esquemas o ejecutando consultas ad hoc.

Protección de datos: Trabajo con copias de seguridad de bases de datos

Al trabajar con MongoDB Lens, considere conectarse a una copia de seguridad de sus datos alojada en una instancia de MongoDB separada.

Comience generando la copia de seguridad con mongodump. A continuación, inicie una nueva instancia de MongoDB (por ejemplo, en un puerto diferente como 27018) y restaure la copia de seguridad allí usando mongorestore. Una vez que esté en ejecución, apunte MongoDB Lens a la cadena de conexión de la instancia de copia de seguridad (por ejemplo, mongodb://localhost:27018/mydatabase).

Este enfoque le brinda un entorno de pruebas para probar operaciones complejas o destructivas sin arriesgar la corrupción accidental de sus datos en vivo.

Protección de datos: Consideraciones sobre el flujo de datos

Consideraciones sobre el flujo de datos: Cómo fluyen sus datos a través del sistema

Al usar un servidor MCP con un proveedor de LLM remoto (como Anthropic a través de Claude Desktop), comprender cómo fluyen sus datos a través del sistema es clave para proteger la información sensible de una exposición no intencionada.

Cuando envía una consulta relacionada con MongoDB a través de su cliente MCP, esto es lo que sucede:

[!NOTE]
Si bien este ejemplo usa una instancia local de MongoDB, los mismos principios se aplican a instancias remotas de MongoDB.

sequenceDiagram
    actor User
    box Local Machine #d4f1f9
        participant Client as MCP Client
        participant Lens as MongoDB Lens
        participant MongoDB as MongoDB Instance
    end
    box Remote Server #ffe6cc
        participant LLM as Remote LLM Provider
    end

    User->>Client: 1. Submit request<br>"Show me all users older than 30"
    Client->>LLM: 2. User request + available tools
    Note over LLM: Interprets request<br>Chooses appropriate tool
    LLM->>Client: 3. Tool selection (find-documents)
    Client->>Lens: 4. Tool run with parameters
    Lens->>MongoDB: 5. Database query
    MongoDB-->>Lens: 6. Database results
    Lens-->>Client: 7. Tool results (formatted data)
    Client->>LLM: 8. Tool results
    Note over LLM: Processes results<br>Formats response
    LLM-->>Client: 9. Processed response
    Client-->>User: 10. Final answer
  1. Envías una solicitud
    ➥ p. ej., "Muéstrame todos los usuarios mayores de 30"
  2. Tu cliente envía la solicitud al LLM remoto
    ➥ El proveedor de LLM recibe tus palabras exactas junto con una lista de herramientas MCP disponibles y sus parámetros.
  3. El LLM remoto interpreta tu solicitud
    ➥ Determina tu intención e indica al cliente que use una herramienta MCP específica con los parámetros adecuados.
  4. El cliente le pide a MongoDB Lens que ejecute la herramienta
    ➥ Esto ocurre localmente en tu máquina mediante stdio.
  5. MongoDB Lens consulta tu base de datos MongoDB
  6. MongoDB Lens recupera los resultados de tu consulta MongoDB
  7. MongoDB Lens envía los datos de vuelta al cliente
    ➥ El cliente recibe los resultados formateados por MongoDB Lens.
  8. El cliente reenvía los datos al LLM remoto
    ➥ El proveedor de LLM ve los datos exactos devueltos por MongoDB Lens.
  9. El LLM remoto procesa los datos
    ➥ Puede resumir o formatear aún más los resultados.
  10. El LLM remoto envía la respuesta final al cliente
    ➥ El cliente te muestra la respuesta.

El proveedor de LLM remoto ve tanto tu solicitud original como la respuesta completa de MongoDB Lens. Si tu base de datos incluye campos sensibles (p. ej., contraseñas, datos personales, etc.), estos datos podrían transmitirse involuntariamente al proveedor remoto a menos que tomes precauciones.

Consideraciones sobre el flujo de datos: Protección de datos sensibles con proyección

Para evitar que los datos sensibles se envíen al proveedor de LLM remoto, usa el concepto de proyección al utilizar herramientas como find-documents, aggregate-data o export-data. La proyección te permite especificar qué campos incluir o excluir en los resultados de la consulta, garantizando que la información sensible permanezca local.

Ejemplo de uso de proyección:

  • "Muéstrame todos los usuarios mayores de 30, pero usa proyección para ocultar sus contraseñas."
    ➥ Usa la herramienta find-documents con proyección

Consideraciones sobre el flujo de datos: Alias de conexión y contraseñas

Al agregar nuevos alias de conexión con la herramienta add-connection-alias, evita agregar alias a URI que contengan contraseñas si usas un proveedor de LLM remoto. Dado que tu solicitud se envía al LLM, cualquier contraseña en la URI podría quedar expuesta. En su lugar, define alias con contraseñas en el archivo de configuración de MongoDB Lens, donde permanecen locales y no se transmiten al LLM.

Consideraciones sobre el flujo de datos: Configuración local para máxima seguridad

Aunque está fuera del alcance de este documento, para el mayor nivel de privacidad de datos, considera usar un cliente MCP local junto con un modelo de LLM alojado localmente. Este enfoque mantiene todas las solicitudes y datos dentro de tu entorno local, eliminando el riesgo de que información sensible se envíe a un proveedor remoto.

Protección de datos: Confirmación para operaciones destructivas

MongoDB Lens implementa un sistema de confirmación basado en tokens para operaciones potencialmente destructivas, que requiere un proceso de dos pasos para ejecutar herramientas que de otro modo podrían resultar en pérdida de datos no controlada:

  1. Primera invocación de la herramienta: Devuelve un token de confirmación de 4 dígitos que caduca después de 5 minutos
  2. Segunda invocación de la herramienta: Ejecuta la operación si se le proporciona el token válido

Para ver un ejemplo del proceso de confirmación, consulta: Trabajar con protección de confirmación

Las herramientas que requieren confirmación incluyen:

  • drop-user: Eliminar un usuario de la base de datos
  • drop-index: Eliminar un índice (posible impacto en el rendimiento)
  • drop-database: Eliminar permanentemente una base de datos
  • drop-collection: Eliminar una colección y todos sus documentos
  • delete-document: Eliminar uno o varios documentos
  • bulk-operations: Al incluir operaciones de eliminación
  • rename-collection: Cuando la colección de destino existe y se eliminará

Este mecanismo de protección tiene como objetivo prevenir la pérdida accidental de datos por errores tipográficos y comandos no intencionados. Es una red de seguridad que garantiza que seas consciente de las consecuencias antes de continuar con acciones potencialmente dañinas.

[!NOTE]
Si trabajas en un entorno controlado donde la pérdida de datos es aceptable, puedes configurar MongoDB Lens para omitir la confirmación y realizar operaciones destructivas de inmediato.

Omitir la confirmación para operaciones destructivas

Es posible que desees omitir el sistema de confirmación por token.

Establece la variable de entorno CONFIG_DISABLE_DESTRUCTIVE_OPERATION_TOKENS en true para ejecutar operaciones destructivas de inmediato sin confirmación:

# Using NPX
CONFIG_DISABLE_DESTRUCTIVE_OPERATION_TOKENS=true npx -y mongodb-lens@latest

# Using Docker
docker run --rm -i --network=host --pull=always -e CONFIG_DISABLE_DESTRUCTIVE_OPERATION_TOKENS='true' furey/mongodb-lens

[!WARNING]
Deshabilitar los tokens de confirmación elimina un mecanismo de seguridad importante. Se recomienda encarecidamente usar esta opción solo en entornos controlados donde la pérdida de datos sea aceptable, como desarrollo o pruebas. Deshabilitar bajo tu propio riesgo.

Protección de datos: Deshabilitar operaciones destructivas

Deshabilitar herramientas

MongoDB Lens incluye varias herramientas que pueden modificar o eliminar datos. Para deshabilitar herramientas específicas, agrégalas al arreglo disabled.tools en tu archivo de configuración:

{
  "disabled": {
    "tools": [
      "drop-user",
      "drop-index",
      "drop-database",
      "drop-collection",
      "delete-document",
      "bulk-operations",
      "rename-collection"
    ]
  }
}

[!NOTE]
Los recursos y los prompts también se pueden deshabilitar mediante las configuraciones disabled.resources y disabled.prompts.

Herramientas de alto riesgo

Estas herramientas pueden causar pérdida inmediata de datos y deben considerarse para deshabilitar en entornos sensibles:

  • drop-user: Elimina usuarios de la base de datos y sus permisos de acceso
  • drop-index: Elimina índices (puede afectar el rendimiento de las consultas)
  • drop-database: Elimina permanentemente bases de datos completas
  • drop-collection: Elimina permanentemente colecciones y todos sus documentos
  • delete-document: Elimina documentos que coinciden con criterios específicos
  • bulk-operations: Puede realizar eliminaciones por lotes cuando está configurado para hacerlo
  • rename-collection: Puede sobrescribir colecciones existentes al usar la opción de eliminar destino

Herramientas de riesgo medio

Estas herramientas pueden modificar datos, pero normalmente no causan pérdida inmediata de datos:

  • create-user: Crea usuarios con permisos que podrían permitir cambios adicionales
  • transaction: Ejecuta múltiples operaciones en una transacción (posibilidad de cambios complejos)
  • update-document: Actualiza documentos que podrían sobrescribir datos existentes

Configuración de solo lectura

Para una configuración completamente de solo lectura, deshabilita todas las herramientas potencialmente destructivas:

{
  "disabled": {
    "tools": [
      "drop-user",
      "drop-index",
      "create-user",
      "transaction",
      "create-index",
      "drop-database",
      "drop-collection",
      "insert-document",
      "update-document",
      "delete-document",
      "bulk-operations",
      "create-database",
      "gridfs-operation",
      "create-collection",
      "rename-collection",
      "create-timeseries"
    ]
  }
}

Esta configuración permite que MongoDB Lens consulte y analice datos mientras previene cualquier modificación, proporcionando múltiples capas de protección contra la pérdida accidental de datos.

Habilitación selectiva de componentes

Además de deshabilitar componentes, especifica exactamente qué componentes deben habilitarse (deshabilitando implícitamente todos los demás) usando las configuraciones enabled en tu archivo de configuración:

{
  "enabled": {
    "tools": [
      "use-database",
      "find-documents",
      "count-documents",
      "aggregate-data"
    ]
  },
  "disabled": {
    "resources": true,
    "prompts": true
  }
}

[!IMPORTANT]
Si un componente aparece tanto en las listas enabled como disabled, la configuración enabled tiene prioridad.

Tutorial

El siguiente tutorial te guía a través de la configuración de un contenedor MongoDB con datos de muestra, y luego el uso de MongoDB Lens para interactuar con él mediante consultas en lenguaje natural:

  1. Iniciar contenedor de datos de muestra
  2. Importar datos de muestra
  3. Conectar MongoDB Lens
  4. Consultas de ejemplo
  5. Trabajar con protección de confirmación

Tutorial: 1. Iniciar contenedor de datos de muestra

[!NOTE]
Este tutorial asume que tienes Docker instalado y ejecutándose en tu sistema.

[!IMPORTANT]
Si Docker ya está ejecutando un contenedor en el puerto 27017, detenlo antes de continuar.

  1. Inicializa el contenedor de datos de muestra:
    docker run --name mongodb-sampledata -d -p 27017:27017 mongo:6
  2. Verifica que el contenedor se esté ejecutando sin problemas:
    docker ps | grep mongodb-sampledata

Tutorial: 2. Importar datos de muestra

MongoDB proporciona varios conjuntos de datos de muestra que usaremos para explorar MongoDB Lens.

  1. Descarga los conjuntos de datos de muestra: 
    curl -LO https://atlas-education.s3.amazonaws.com/sampledata.archive
  2. Copia los conjuntos de datos de muestra en tu contenedor de datos de muestra:
    docker cp sampledata.archive mongodb-sampledata:/tmp/
  3. Importa los conjuntos de datos de muestra en MongoDB:
    docker exec -it mongodb-sampledata mongorestore --archive=/tmp/sampledata.archive

Esto importará varias bases de datos:

  • sample_airbnb: Listados y reseñas de Airbnb
  • sample_analytics: Datos de clientes y cuentas
  • sample_geospatial: Datos geográficos
  • sample_mflix: Datos de películas
  • sample_restaurants: Datos de restaurantes
  • sample_supplies: Datos de cadena de suministro
  • sample_training: Datos de entrenamiento para diversas aplicaciones
  • sample_weatherdata: Mediciones meteorológicas

Tutorial: 3. Conectar MongoDB Lens

Instala MongoDB Lens según las instrucciones de Inicio rápido.

Configura tu Cliente MCP para conectarse a MongoDB Lens mediante: mongodb://localhost:27017

[!TIP]
Omitir la cadena de conexión de la configuración de tu Cliente MCP hará que la cadena de conexión predeterminada sea mongodb://localhost:27017.

Ejemplo de configuración de Claude Desktop:

{
  "mcpServers": {
    "mongodb-lens": {
      "command": "/path/to/npx",
      "args": [
        "-y",
        "mongodb-lens@latest"
      ]
    }
  }
}

Tutorial: 4. Consultas de ejemplo

Con tu Cliente MCP ejecutándose y conectado a MongoDB Lens, prueba las siguientes consultas de ejemplo:

Consultas de ejemplo: Operaciones básicas de base de datos

  • "Lista todas las bases de datos"
    ➥ Usa la herramienta list-databases
  • "¿Qué base de datos estoy usando actualmente?"
    ➥ Usa la herramienta current-database
  • "Cambia a la base de datos sample_mflix"
    ➥ Usa la herramienta use-database
  • "Crea una nueva base de datos llamada test_db"
    ➥ Usa la herramienta create-database
  • "Crea otra base de datos llamada analytics_db y cambia a ella"
    ➥ Usa la herramienta create-database con switch=true
  • "Elimina test_db"
    ➥ Usa la herramienta drop-database (con confirmación)

Consultas de ejemplo: Gestión de colecciones

  • "¿Qué colecciones hay en la base de datos actual?"
    ➥ Usa la herramienta list-collections
  • "Crea la colección user_logs"
    ➥ Usa la herramienta create-collection
  • "Renombra user_logs a system_logs"
    ➥ Usa la herramienta rename-collection
  • "Elimina system_logs"
    ➥ Usa la herramienta drop-collection (con confirmación)
  • "Verifica la consistencia de datos en la colección movies"
    ➥ Usa la herramienta validate-collection

Consultas de ejemplo: Gestión de usuarios

  • "Crear un usuario de solo lectura para análisis"
    ➥ Usa la herramienta create-user
  • "Eliminar la cuenta de inactive_user"
    ➥ Usa la herramienta drop-user (con confirmación)

Ejemplos de consultas: Consulta de datos

  • "Contar todos los documentos en la colección movies"
    ➥ Usa la herramienta count-documents
  • "Encontrar las 5 mejores películas con la calificación IMDB más alta"
    ➥ Usa la herramienta find-documents
  • "Muéstrame datos agregados de películas agrupadas por década"
    ➥ Usa la herramienta aggregate-data
  • "Lista todos los países únicos donde se produjeron películas"
    ➥ Usa la herramienta distinct-values
  • "Buscar películas que contengan godfather en su título"
    ➥ Usa la herramienta text-search
  • "Encontrar usuarios alemanes con apellido müller usando la intercalación adecuada"
    ➥ Usa la herramienta collation-query

Ejemplos de consultas: Análisis de esquema

  • "¿Cuál es la estructura de esquema de la colección movies?"
    ➥ Usa la herramienta analyze-schema
  • "Comparar esquemas de users y comments"
    ➥ Usa la herramienta compare-schemas
  • "Generar un validador de esquema para la colección movies"
    ➥ Usa la herramienta generate-schema-validator
  • "Analizar patrones de consulta comunes para la colección movies"
    ➥ Usa la herramienta analyze-query-patterns

Ejemplos de consultas: Modificación de datos

  • "Insertar nuevo documento de película: <your field data>"
    ➥ Usa la herramienta insert-document
  • "Actualizar todas las películas de 1994 para agregar un indicador 'clásico'"
    ➥ Usa la herramienta update-document
  • "Eliminar todas las películas con cero calificaciones"
    ➥ Usa la herramienta delete-document (con confirmación)
  • "Ejecutar estas operaciones masivas en la colección movies: <your JSON data>"
    ➥ Usa la herramienta bulk-operations

[!TIP]
Para operaciones especializadas de MongoDB (como operaciones de arreglos, operaciones bit a bit u otras actualizaciones complejas), usa los operadores nativos de MongoDB a través de la herramienta update-document y sus parámetros update y options.

Ejemplos de consultas: Rendimiento y gestión de índices

  • "Crear un índice en el campo title de la colección movies"
    ➥ Usa la herramienta create-index
  • "Eliminar el índice ratings_idx"
    ➥ Usa la herramienta drop-index (con confirmación)
  • "Explicar el plan de ejecución para encontrar películas de 1995"
    ➥ Usa la herramienta explain-query
  • "Obtener estadísticas de la base de datos actual"
    ➥ Usa la herramienta get-stats con target=database
  • "Mostrar estadísticas de la colección movies"
    ➥ Usa la herramienta get-stats con target=collection

Ejemplos de consultas: Operaciones geoespaciales y especiales

  • "Cambiar a la base de datos sample_geospatial, luego encontrar todos los naufragios dentro de 10 km de las coordenadas [-80.12, 26.46]"
    ➥ Usa la herramienta geo-query
  • "Cambiar a la base de datos sample_analytics, luego ejecutar una transacción para mover fondos entre cuentas: <account ids>"
    ➥ Usa la herramienta transaction
  • "Crear una colección de series temporales para lecturas de sensores"
    ➥ Usa la herramienta create-timeseries
  • "Observar cambios en la colección users durante 30 segundos"
    ➥ Usa la herramienta watch-changes
  • "Listar todos los archivos en el bucket GridFS de images"
    ➥ Usa la herramienta gridfs-operation con operation=list

Ejemplos de consultas: Exportación, administración y otras características

  • "Cambiar a la base de datos sample_mflix, luego exportar las 20 mejores películas según 'tomatoes.critic.rating' como CSV con los campos title, year y rating (salida en un solo bloque de código)"
    ➥ Usa la herramienta export-data
  • "Cambiar a la base de datos sample_analytics, luego verificar su estado de sharding"
    ➥ Usa la herramienta shard-status
  • "Limpiar la caché de colecciones"
    ➥ Usa la herramienta clear-cache con target=collections
  • "Limpiar todas las cachés"
    ➥ Usa la herramienta clear-cache
  • "Cambiar a la base de datos sample_weatherdata y luego generar un informe interactivo sobre su estado actual"
    ➥ Usa numerosas herramientas

Ejemplos de consultas: Gestión de conexiones

  • "Conectar a mongodb://localhost:27018"
    ➥ Usa la herramienta connect-mongodb
  • "Conectar a mongodb+srv://username:password@cluster.mongodb.net/mydb"
    ➥ Usa la herramienta connect-mongodb
  • "Volver a conectar a la instancia original de mongodb"
    ➥ Usa la herramienta connect-original
  • "Conectar a un conjunto de réplicas sin validar la conexión: <replica set details>"
    ➥ Usa la herramienta connect-mongodb con validateConnection=false
  • "Agregar alias de conexión 'prod' para mongodb://username:password@prod-server:27017/mydb"
    ➥ Usa la herramienta add-connection-alias

Tutorial: 5. Trabajando con la protección de confirmación

MongoDB Lens incluye un mecanismo de seguridad para operaciones potencialmente destructivas. Así es como funciona en la práctica:

  1. Solicitar eliminar una colección:
    "Drop the collection named test_collection"
  2. MongoDB Lens responde con una advertencia y un token de confirmación:
    ⚠️ DESTRUCTIVE OPERATION WARNING ⚠️

You've requested to drop the collection 'test_collection'.

This operation is irreversible and will permanently delete all data in this collection.

To confirm, you must type the 4-digit confirmation code EXACTLY as shown below:

Confirmation code: 9876

This code will expire in 5 minutes for security purposes.
  3. Confirmar la operación enviando el token de confirmación:
    "9876"
  4. MongoDB Lens ejecuta la operación:
    Collection 'test_collection' has been permanently deleted.

Este proceso de dos pasos evita la pérdida accidental de datos al requerir confirmación explícita.

[!NOTE]
Si trabajas en un entorno controlado donde la pérdida de datos es aceptable, puedes configurar MongoDB Lens para omitir la confirmación y realizar operaciones destructivas de inmediato.

Suite de pruebas

MongoDB Lens incluye una suite de pruebas para verificar la funcionalidad en herramientas, recursos y prompts.

Suite de pruebas: Ejecutar pruebas

La suite de pruebas requiere una variable de entorno CONFIG_MONGO_URI que puede establecerse en:

  • una cadena de conexión de MongoDB (por ejemplo, mongodb://localhost:27017)
  • mongodb-memory-server (para pruebas en memoria)
# Run Tests with MongoDB Connection String
CONFIG_MONGO_URI=mongodb://localhost:27017 node mongodb-lens.test.js

# Run Tests with In-Memory MongoDB (requires mongodb-memory-server)
CONFIG_MONGO_URI=mongodb-memory-server node mongodb-lens.test.js

Para mayor comodidad, los siguientes scripts están disponibles para ejecutar pruebas:

npm test                        # Fails if no CONFIG_MONGO_URI provided
npm run test:localhost          # Uses mongodb://localhost:27017
npm run test:localhost:verbose  # Runs with DEBUG=true for verbose output
npm run test:in-memory          # Uses mongodb-memory-server
npm run test:in-memory:verbose  # Runs with DEBUG=true for verbose output

[!NOTE]
La suite de pruebas crea bases de datos y colecciones temporales que se limpian al finalizar las pruebas.

Suite de pruebas: Opciones de línea de comandos

OpciónDescripción
--listListar todas las pruebas disponibles sin ejecutarlas
--test=<n>Ejecutar prueba(s) específica(s) por nombre (separadas por comas)
--group=<n>Ejecutar todas las pruebas en grupo(s) específico(s) (separados por comas)
--pattern=<glob>Ejecutar pruebas que coincidan con patrón(es) (separados por comas)

Suite de pruebas: Ejemplos

# List All Available Tests
npm test -- --list

# Run Only Connection-Related Tests (:27017)
npm run test:localhost -- --group=Connection\ Tools

# Test Specific Database Operations (In-Memory)
npm run test:in-memory -- --test=create-database\ Tool,drop-database\ Tool

# Test All Document-Related Tools (:27017)
npm run test:localhost -- --pattern=document

# Run Resource Tests Only (In-Memory)
npm run test:in-memory -- --group=Resources

# Run Specific Tests Only (In-Memory)
npm run test:in-memory -- --test=aggregate-data\ Tool,find-documents\ Tool

Descargo de responsabilidad

MongoDB Lens:

  • está licenciado bajo la Licencia MIT.
  • no está afiliado ni respaldado por MongoDB, Inc.
  • está escrito con la asistencia de IA y puede contener errores.
  • está destinado únicamente a fines educativos y experimentales.
  • se proporciona tal cual, sin garantía: úsalo bajo tu propio riesgo.

Soporte

Si has encontrado útil MongoDB Lens, considera apoyar mi trabajo a través de:

Buy Me a Coffee | GitHub Sponsorship

Las contribuciones me ayudan a seguir desarrollando y mejorando esta herramienta, permitiéndome dedicar más tiempo a agregar nuevas funciones y asegurando que siga siendo un recurso valioso para la comunidad.