Qué es MongoDB y cómo funciona: Guía para Principiantes

Cuando aprendes bases de datos, el primer modelo que encuentras es el relacional: tablas, filas, columnas, SQL. Y funciona muy bien para muchísimos problemas. Pero hay un tipo de datos que las tablas no manejan tan bien: los datos que cambian de forma, los que no encajan en una estructura rígida, los que vienen de APIs modernas en formato JSON.

Ahí es donde entra MongoDB. Una base de datos que en lugar de guardar información en tablas la guarda en documentos, como si cada registro fuera un objeto JSON independiente con su propia estructura.

Es la base de datos NoSQL más popular del mundo, y en 2026 sigue siendo una habilidad muy buscada en el mercado laboral. Esta guía te explica qué es, cómo funciona, cuándo usarla y cómo dar tus primeros pasos con ella.

¿Qué es MongoDB?

MongoDB (del inglés humongous, "enorme") es un sistema de gestión de bases de datos NoSQL orientado a documentos, de código abierto, escrito en C++ y lanzado en 2009. En lugar de almacenar los datos en tablas con filas y columnas como hacen MySQL o PostgreSQL, MongoDB los almacena en documentos con formato BSON (Binary JSON), organizados dentro de colecciones.

Es la base de datos NoSQL más usada del mundo y forma parte del popular stack MEAN y MERN (MongoDB + Express + Angular/React + Node.js), que son dos de las combinaciones de tecnologías más demandadas en desarrollo web.

Empresas como Google, Facebook, Adobe, SEGA, Bosch y Forbes usan MongoDB en producción para gestionar grandes volúmenes de datos con estructuras flexibles.

La analogía que lo explica todo

Imagina que tienes que organizar la información de una biblioteca:

Con una base de datos SQL (relacional): creas una tabla libros con columnas fijas: id, titulo, autor, año, isbn. Todos los libros tienen exactamente esas columnas. Si un libro tiene dos autores, tienes que crear otra tabla de autores y hacer un JOIN. Si quieres añadir una nueva propiedad (por ejemplo, traducido_por), tienes que alterar la estructura de la tabla completa.

Con MongoDB: cada libro es un documento independiente. Un libro puede tener un autor, otro puede tener tres autores en un array, otro puede tener campos adicionales que los demás no tienen. No hay tabla rígida que seguir. Cada documento decide su propia estructura.

// SQL: todos los libros tienen exactamente las mismas columnas
// Si un campo no aplica, el valor es NULL

id | titulo              | autor         | año  | isbn
---+---------------------+---------------+------+----------------
 1 | Don Quijote         | Cervantes     | 1605 | 978-84-376-0494
 2 | Cien años soledad   | García Márquez| 1967 | 978-03-060-8876
 3 | El nombre de la rosa| Eco           | 1980 | NULL (no ISBN)

// MongoDB: cada documento puede tener su propia estructura

// Libro 1 — estructura básica
{
  "_id": ObjectId("..."),
  "titulo": "Don Quijote",
  "autor": "Miguel de Cervantes",
  "año": 1605,
  "isbn": "978-84-376-0494-8"
}

// Libro 2 — con array de autores
{
  "_id": ObjectId("..."),
  "titulo": "Good Omens",
  "autores": ["Terry Pratchett", "Neil Gaiman"],
  "año": 1990,
  "generos": ["fantasía", "comedia"],
  "disponible": true
}

// Libro 3 — con objeto anidado
{
  "_id": ObjectId("..."),
  "titulo": "Clean Code",
  "autor": {
    "nombre": "Robert C. Martin",
    "conocido_como": "Uncle Bob"
  },
  "ediciones": [2008, 2012, 2019],
  "paginas": 431
}

Cada documento tiene lo que necesita. Sin columnas vacías, sin JOINs obligatorios, sin esquema fijo.

Conceptos fundamentales de MongoDB

📄 Documento — la unidad básica de datos

Un documento en MongoDB es equivalente a una fila en SQL, pero mucho más flexible. Se almacena en formato BSON (Binary JSON), que es una extensión binaria de JSON que permite tipos de datos adicionales como fechas, enteros de 64 bits y datos binarios.

Cada documento tiene un campo obligatorio: _id, que actúa como clave primaria única. Si no lo especificas, MongoDB lo genera automáticamente como un ObjectId.

{
  "_id": ObjectId("64abc123def456789012abcd"),  // generado automáticamente
  "nombre": "Ana García",
  "email": "ana@ejemplo.com",
  "edad": 28,
  "activo": true,
  "direccion": {                    // objeto anidado
    "calle": "Av. Principal 123",
    "ciudad": "Madrid",
    "pais": "España"
  },
  "intereses": ["Python", "MongoDB", "Machine Learning"], // array
  "creado": ISODate("2026-01-15T10:30:00Z")
}

📁 Colección — el equivalente a una tabla

Una colección es un grupo de documentos, similar a una tabla en SQL. La diferencia clave: los documentos dentro de una colección no necesitan tener la misma estructura entre sí.

// En SQL: una tabla tiene esquema fijo
// tabla: usuarios
// columnas: id, nombre, email, edad (todos los registros tienen estas columnas)

// En MongoDB: una colección agrupa documentos relacionados
// colección: usuarios
// Cada documento puede tener campos diferentes

🗄️ Base de datos — agrupa colecciones

Una base de datos en MongoDB contiene múltiples colecciones, igual que en SQL. Un servidor MongoDB puede manejar múltiples bases de datos simultáneamente.

// Estructura jerárquica de MongoDB:

Servidor MongoDB
├── Base de datos: tienda
│   ├── Colección: productos
│   ├── Colección: clientes
│   └── Colección: pedidos
├── Base de datos: blog
│   ├── Colección: articulos
│   └── Colección: comentarios
└── Base de datos: analytics
    └── Colección: eventos

🔑 ObjectId — identificador único automático

El _id de tipo ObjectId que MongoDB genera automáticamente no es un número secuencial como en SQL. Es un valor de 12 bytes que codifica:

• ⏱️ 4 bytes: marca de tiempo Unix (cuándo se creó)
• 🖥️ 5 bytes: identificador único del proceso que lo creó
• 🔢 3 bytes: contador incremental aleatorio

Esto garantiza unicidad global incluso en sistemas distribuidos con múltiples servidores escribiendo al mismo tiempo.

MongoDB vs SQL: la comparativa de conceptos

Operaciones CRUD en MongoDB

CRUD = Create, Read, Update, Delete. Son las operaciones básicas de cualquier base de datos. Aquí van con ejemplos usando la colección productos:

📥 CREATE — insertar documentos

// Insertar un solo documento
db.productos.insertOne({
  nombre: "Laptop Pro 15",
  precio: 899.99,
  stock: 20,
  categoria: "tecnologia",
  especificaciones: {
    ram: "16GB",
    almacenamiento: "512GB SSD",
    procesador: "Intel i7"
  },
  etiquetas: ["laptop", "trabajo", "premium"],
  creado: new Date()
})

// Insertar múltiples documentos
db.productos.insertMany([
  { nombre: "Mouse Inalámbrico", precio: 29.99, stock: 150, categoria: "periféricos" },
  { nombre: "Teclado Mecánico",  precio: 79.99, stock: 80,  categoria: "periféricos" },
  { nombre: "Monitor 4K",        precio: 399.99, stock: 25, categoria: "pantallas" }
])

🔍 READ — consultar documentos

// Obtener todos los documentos
db.productos.find()

// Con filtro: productos de la categoría "periféricos"
db.productos.find({ categoria: "periféricos" })

// Con múltiples filtros: periféricos con precio menor a 50
db.productos.find({
  categoria: "periféricos",
  precio: { $lt: 50 }  // $lt = less than (menor que)
})

// Proyección: solo mostrar nombre y precio (sin el _id)
db.productos.find(
  { categoria: "tecnologia" },
  { nombre: 1, precio: 1, _id: 0 }
)

// Ordenar por precio descendente
db.productos.find().sort({ precio: -1 })

// Limitar resultados: solo los 3 más baratos
db.productos.find().sort({ precio: 1 }).limit(3)

// Obtener un solo documento
db.productos.findOne({ nombre: "Laptop Pro 15" })

Operadores de consulta más comunes

// Comparación
{ precio: { $gt: 100 } }    // mayor que (greater than)
{ precio: { $lt: 500 } }    // menor que (less than)
{ precio: { $gte: 50 } }    // mayor o igual
{ precio: { $lte: 400 } }   // menor o igual
{ precio: { $ne: 0 } }      // diferente de (not equal)

// Dentro de un array de valores
{ categoria: { $in: ["tecnologia", "periféricos"] } }
{ categoria: { $nin: ["ropa", "comida"] } }

// Lógicos
{ $and: [ { precio: { $gt: 50 } }, { stock: { $gt: 0 } } ] }
{ $or:  [ { categoria: "tecnologia" }, { precio: { $lt: 30 } } ] }
{ precio: { $not: { $lt: 100 } } }

// Existencia de campo
{ descuento: { $exists: true } }   // tiene el campo descuento
{ descuento: { $exists: false } }  // no tiene el campo descuento

// Búsqueda en arrays
{ etiquetas: "premium" }                           // array contiene "premium"
{ etiquetas: { $all: ["laptop", "premium"] } }     // array contiene ambos
{ etiquetas: { $size: 3 } }                        // array tiene exactamente 3 elementos

✏️ UPDATE — actualizar documentos

// Actualizar un documento — solo los campos especificados
db.productos.updateOne(
  { nombre: "Laptop Pro 15" },          // filtro: qué documento
  { $set: { precio: 849.99, stock: 18 } } // qué cambiar
)

// Actualizar múltiples documentos
db.productos.updateMany(
  { categoria: "periféricos" },         // todos los periféricos
  { $set: { en_oferta: true } }         // añadir campo en_oferta
)

// Incrementar un valor numérico
db.productos.updateOne(
  { nombre: "Mouse Inalámbrico" },
  { $inc: { stock: -1 } }  // restar 1 al stock (una venta)
)

// Añadir elemento a un array
db.productos.updateOne(
  { nombre: "Laptop Pro 15" },
  { $push: { etiquetas: "oferta" } }
)

// Eliminar un campo
db.productos.updateOne(
  { nombre: "Mouse Inalámbrico" },
  { $unset: { en_oferta: "" } }
)

🗑️ DELETE — eliminar documentos

// Eliminar un documento
db.productos.deleteOne({ nombre: "Monitor 4K" })

// Eliminar múltiples documentos
db.productos.deleteMany({ stock: 0 })  // eliminar productos sin stock

// Eliminar todos los documentos de una colección
db.productos.deleteMany({})  // ⚠️ cuidado: borra todo

Cómo instalar y empezar con MongoDB

Opción 1: MongoDB Atlas (recomendada para empezar)

MongoDB Atlas es la versión en la nube gestionada por los propios creadores de MongoDB. Tiene un plan gratuito generoso (512MB) y no necesitas instalar nada en tu computadora.

1. Ve a cloud.mongodb.com y crea una cuenta gratuita
2. Crea un nuevo cluster (elige el plan Free Tier M0)
3. Configura un usuario y contraseña
4. Conecta desde tu aplicación con la cadena de conexión que te proporcionan

Opción 2: Instalación local

# En macOS con Homebrew
brew tap mongodb/brew
brew install mongodb-community
brew services start mongodb-community

# En Ubuntu/Debian
wget -qO - https://www.mongodb.org/static/pgp/server-7.0.asc | sudo apt-key add -
echo "deb [ arch=amd64 ] https://repo.mongodb.org/apt/ubuntu jammy/mongodb-org/7.0 multiverse" | sudo tee /etc/apt/sources.list.d/mongodb-org-7.0.list
sudo apt-get update && sudo apt-get install -y mongodb-org
sudo systemctl start mongod

# Verificar instalación — abre el shell de MongoDB
mongosh

MongoDB con Node.js — usando Mongoose

Mongoose es la librería más popular para usar MongoDB desde Node.js. Añade validaciones, esquemas opcionales y una API muy cómoda:

npm install mongoose

// conexion.js
const mongoose = require('mongoose');

mongoose.connect('mongodb://localhost:27017/mitienda')
  .then(() => console.log('✅ Conectado a MongoDB'))
  .catch(err => console.error('❌ Error:', err));

// Definir un esquema (opcional pero recomendado con Mongoose)
const productoSchema = new mongoose.Schema({
  nombre:    { type: String, required: true },
  precio:    { type: Number, required: true, min: 0 },
  stock:     { type: Number, default: 0 },
  categoria: { type: String, enum: ['tecnologia', 'periféricos', 'pantallas'] },
  etiquetas: [String],
  creado:    { type: Date, default: Date.now }
});

const Producto = mongoose.model('Producto', productoSchema);

// Crear un producto
const nuevoProducto = new Producto({
  nombre: 'Laptop Pro 15',
  precio: 899.99,
  stock: 20,
  categoria: 'tecnologia',
  etiquetas: ['laptop', 'premium']
});

await nuevoProducto.save();

// Consultar
const productos = await Producto.find({ categoria: 'tecnologia' })
  .sort({ precio: -1 })
  .limit(10);

// Actualizar
await Producto.updateOne(
  { nombre: 'Laptop Pro 15' },
  { $set: { precio: 849.99 } }
);

// Eliminar
await Producto.deleteOne({ _id: '64abc123...' });

¿Cuándo usar MongoDB y cuándo no?

✅ MongoDB es ideal cuando:

• Los datos tienen estructura variable — perfiles de usuario con campos diferentes, catálogos de productos con especificaciones distintas por categoría
• Necesitas escalar horizontalmente — distribuir datos en múltiples servidores para manejar millones de registros
• Trabajas con datos de APIs y JSON — los datos ya llegan en JSON, guardarlos directamente es natural
• El esquema cambia frecuentemente — en startups y proyectos en evolución donde los requisitos cambian cada semana
• Velocidad de desarrollo es crítica — prototipas más rápido sin definir esquemas complejos
• Big Data, IoT y logs — millones de eventos con estructuras diversas
• Catálogos de e-commerce — cada producto puede tener atributos completamente diferentes
• Redes sociales y contenido — posts, comentarios, reacciones con estructuras anidadas

❌ MongoDB NO es la mejor opción cuando:

• Necesitas transacciones complejas y garantías ACID fuertes — sistemas bancarios, contabilidad, donde un error parcial es inaceptable
• Los datos son altamente relacionales — muchas tablas con JOIN complejos entre sí
• El esquema es muy estable y conocido — si sabes exactamente los campos que tendrás siempre, SQL es más eficiente
• Necesitas consultas analíticas complejas — reportes con múltiples grupos, subtotales y cálculos complejos

Ventajas y desventajas de MongoDB

MongoDB en el mundo real: casos de uso conocidos

• 🎮 SEGA — almacena datos de partidas y estadísticas de jugadores
• 📰 Forbes — gestión de contenidos del sitio con millones de artículos
• 🛒 eBay — catálogo de productos con estructuras diversas
• 📱 Twitter/X — almacenamiento de tweets y metadatos
• 🏥 Electronic Arts — datos de juegos online y perfiles de usuarios
• 🔍 Adobe — almacenamiento de metadatos de activos digitales

Resumen: lo que aprendiste hoy

• ✅ MongoDB es una base de datos NoSQL orientada a documentos, de código abierto
• ✅ Almacena datos en documentos BSON (Binary JSON) en lugar de tablas y filas
• ✅ Los documentos de una colección no necesitan tener el mismo esquema
• ✅ Los conceptos clave son: documento, colección, base de datos y _id (ObjectId)
• ✅ Las operaciones CRUD usan: insertOne/Many, find/findOne, updateOne/Many, deleteOne/Many
• ✅ MongoDB Atlas es la opción cloud gratuita perfecta para empezar sin instalar nada
• ✅ Mongoose es la librería estándar para usar MongoDB desde Node.js
• ✅ Es ideal para datos flexibles, APIs JSON, Big Data e IoT
• ✅ No es la mejor opción para transacciones financieras complejas ni datos muy relacionales
• ✅ Forma parte del stack MEAN/MERN, muy demandado en el mercado laboral

🧪 ¿Tienes claras las diferencias entre SQL y NoSQL?

MongoDB es el rey de las bases de datos NoSQL de documentos. Pero para elegir correctamente cuándo usar MongoDB y cuándo SQL, necesitas entender bien las diferencias entre ambos mundos. Comprueba dónde estás:

👉 Test: SQL vs NoSQL 👉 Test: NoSQL Fundamentos y Tipos 

¿Ya habías trabajado con MongoDB antes? ¿Vienes del mundo SQL y te costó el cambio de mentalidad? ¿Tienes alguna duda con los operadores de consulta? Cuéntanos en los comentarios 👇 — respondemos todos. 🚀