Transacciones ACID con fsync real. Búsqueda full-text en <1ms. Analítica sobre millones de registros. Búsqueda vectorial con HNSW para IA/RAG. Audit log inmutable. Recuperación ante desastres con WAL. Un solo binario. Una sola fuente de verdad.
$ ./neodb --data-dir ./data SLM NeoDB SLMTR1 starting... Engine: SLMTR1 | Status: READY Listening on 127.0.0.1:7700 $ curl -X POST :7700/banco/user/1 \ -d '{"nombre":"Luis","saldo":1500.25}' 201 Created — 8ms, fsync'd $ curl :7700/banco/user/_search \ -d '{"query":{"match":{"nombre":"luis"}}}' 200 OK — <1ms, 1 result
NeoDB es la primera base de datos que unifica datos transaccionales, búsqueda full-text, analytics en tiempo real, y RAG/AI en un solo motor. Sin sincronizar PostgreSQL con Elasticsearch con Pinecone. Un binario. Una fuente de verdad. ACID real.
Tiene vectores pero búsqueda de texto lenta y sin aggregations rápidas.
Tiene búsqueda pero no tiene ACID ni vectores nativos eficientes.
Solo vectores. No son bases de datos transaccionales.
Todo en uno. ACID + búsqueda + analytics + vectores.
Otras bases de datos te obligan a elegir entre 8+ tipos numéricos. Elige mal y pierdes dinero. NeoDB tiene UN solo tipo.
8+ tipos numéricos: NUMBER, DECIMAL, FLOAT, DOUBLE PRECISION, REAL, BIGINT, SMALLINT, NUMERIC. Elige el incorrecto y pierdes centavos. En millones de transacciones, pierdes miles.
Usa IEEE 754 double. 0.1 + 0.2 = 0.30000000000000004. Inaceptable para dinero. Inaceptable para auditoría. Inaceptable.
UN tipo: number[n]. n = decimales. Precisión exacta. NUNCA redondea. Si envías decimales de más, rechaza con error.
// Elasticsearch (IEEE 754 double) 0.1 + 0.2 = 0.30000000000000004 <-- WRONG // NeoDB (number[2]) 0.1 + 0.2 = 0.30 <-- EXACT. Always.
number[0] = entero. number[2] = dinero. number[8] = crypto. Un tipo. Cero errores.
El developer describe QUÉ es su dato. El motor decide CÓMO almacenarlo, indexarlo y buscarlo.
NeoDB es como un mapa mental para tus datos. No necesitas diseñar todo desde el principio. Empieza a guardar, descubre lo que necesitas, y crece progresivamente.
Sin schema. Manda JSON y NeoDB lo acepta. No necesitas saber la estructura final.
Haz queries, busca por texto, filtra. Los datos te dicen qué estructura necesitas.
Define tipos, validaciones, strict mode. En caliente. Sin downtime. Sin migrar datos.
Agrega campos, crea nuevos tipos, nuevos índices. Los datos existentes no se tocan.
En SQL, diseñas tablas antes de escribir la primera línea de código. En NeoDB, escribes código desde el minuto uno y el schema evoluciona contigo. Es la base de datos para equipos que construyen productos, no para equipos que diseñan schemas.
349 tests · 0 warnings · 21K docs/sec · <1ms search · 27MB binary
No es un plugin. No es un add-on. Está en el motor.
Tu DBA no puede filtrar un PAN porque fisicamente nunca toca el disco. El motor lo hashea con BLAKE3 antes de almacenarlo. El valor original se descarta en RAM. Para siempre.
Una API key robada es inútil fuera del rango de IP autorizado. Silent drop — el atacante ni siquiera recibe un mensaje de error.
El equipo de reportes ve transacciones pero nunca ve números de tarjeta. Field masking por key, aplicado a nivel del motor.
Cada operación. Cada key. Cada IP. Inmutable. PCI DSS REQ 10 compliant de fábrica.
Los requests inválidos reciben TCP close. Sin respuesta HTTP. Sin código de error. Sin fuga de información. El atacante no sabe en qué paso falló.
BLAKE3 de 256 bits — 128 bits de seguridad post-quantum. Los datos hasheados con blind (PANs, identificaciones, datos sensibles) permanecen protegidos incluso contra computadoras cuánticas futuras. Impracticable con tecnología actual o futura previsible.
Cada operación queda en un ledger inmutable con timestamp, identidad y evidencia criptográfica. Sin nodos, sin gas, sin consenso distribuido.
Soft deletes. Cada versión de cada documento queda en el historial. Un auditor puede reconstruir el estado de cualquier dato en cualquier momento del pasado.
Cada operación registrada con: quién (key_id), cuándo (timestamp), desde dónde (IP), qué hizo (acción), resultado (ALLOWED/DENIED), duración. Append-only. Nadie puede modificarlo.
BLAKE3 de 256 bits (quantum-resistant). Cada hash es prueba matemática de integridad. IDs con UUID v7 cronológico — orden garantizado por el protocolo, no por un reloj.
Nodos, consenso distribuido, gas fees, latencia de confirmación, throughput limitado, complejidad operativa extrema.
Un binario, fsync inmediato, 21K escrituras/segundo, audit log inmutable, hashing quantum-resistant, zero complejidad operativa. Misma inmutabilidad. Sin el overhead.
Consistencia o búsqueda. ACID o velocidad. Y luego pegarlos con cinta. NeoDB elimina esa elección.
✓ ACID
✗ Búsqueda lenta
✗ Sin analytics rápido
✓ Búsqueda rápida
✗ Sin ACID
✗ Consistencia eventual
✗ Dos sistemas
✗ Sincronización rota
✗ ¿Cuál es la verdad?
✓ ACID
✓ Búsqueda <1ms
✓ Una fuente de verdad
1.1 millones de documentos. 5 módulos de negocio. Hardware estándar.
Sin JVM. Sin cluster. Sin tuning de shards. Sin replica sets. Sin heap sizing. Sin GC tuning. Descarga, ejecuta, funciona.
REST + JSON. Sin SQL. Sin ORM. Sin drivers.
# Crear curl -X POST :7700/banco/user/1 \ -H "SLM-KEY: $KEY" \ -d '{"nombre":"Luis","saldo":1500.25}' # Buscar curl -X POST :7700/banco/user/_search \ -H "SLM-KEY: $KEY" \ -d '{"query":{"match":{"nombre":"luis"}}}' # Agregar curl -X POST :7700/banco/transaction/_search \ -H "SLM-KEY: $KEY" \ -d '{"aggs":{"total":{"sum":{"field":"monto"}}},"size":0}'
Cada función está implementada y probada. 349 tests. 0 warnings.
fsync antes de ACK. Sobrevive corte de luz.
Tantivy — Apache Lucene reescrito en Rust. La misma tecnología que usa Elasticsearch pero sin JVM, sin GC pauses, 2x más rápido. BM25. <1ms sobre millones.
SUM/AVG/MAX/MIN/terms/histogram. Fast fields nativos.
Precisión decimal exacta. Sin errores IEEE 754.
BLAKE3 hash. El PAN nunca toca el disco. PCI DSS.
API key + binding por IP. Silent drop.
Cada operación registrada. Inmutable. PCI REQ 10.
Nada se pierde. Historial completo.
Campos calculados. Aggregations stateful. Sandbox.
KNN con cosine/dot/euclidean. Auto-normalización.
geo_distance, geo_bounding_box, Haversine.
Feed de cambios en tiempo real desde el WAL.
21K docs/seg. Un solo fsync por batch.
Dev tools embebido. Como Kibana.
Endpoint /_metrics. Grafana-ready.
Rotación zero-downtime. Blue-green deploys.
Rotación de índices, búsqueda con glob, TTL automático y date_histogram. Sin Loki. Sin InfluxDB. Sin TimescaleDB. Con ACID y full-text search.
# Index rotation — one index per month curl -X POST :7700/trxs-2026-01/transaction/1 \ -d '{"tipo":"deposito","monto":500.00,"fecha":"2026-01-15"}' # Glob search — query across all months curl -X POST :7700/trxs-2026-*/_search \ -d '{"query":{"range":{"monto":{"gte":100}}}}' # date_histogram — aggregate by month curl -X POST :7700/trxs-*/_search \ -d '{"aggs":{"by_month":{"date_histogram":{ "field":"fecha","calendar_interval":"month"}}}, "size":0}' # TTL — auto-expire logs after 90 days curl -X PUT :7700/logs-2026-01/_settings \ -d '{"ttl":"90d"}'
Scripts server-side en Rhai. Sin round-trips. Sin descargar datos. El cálculo se ejecuta dentro del motor.
// Apply IVA to 100K transactions in one request POST /banco/transaction/_update_by_query { "query": {"term": {"tipo": "deposito"}}, "script": "this.monto = this.monto * 1.16" } // 100,000 transactions x IVA calculation = 6.81 seconds
Actualiza miles de documentos con un script
Campos calculados en tiempo de búsqueda
Relevancia personalizada con lógica de negocio
Aggregations stateful con acumulador
Una consola de desarrollo embebida en cada instancia de NeoDB. Como Kibana Dev Tools — pero sin instalar nada extra.
Editor Monaco (el mismo de VS Code) con autocompletado del DSL de NeoDB. Escribe GET /_health, presiona Ctrl+Enter, ve el resultado al lado. Sin Postman, sin curl, sin configurar nada.
Abre http://tu-servidor:7700/_console desde cualquier máquina. Tus workspaces se guardan en la misma base de datos. Cambias de laptop y todo está ahí.
# Así se ve. Escribe el verbo, el path, y el body. # Ctrl+Enter para ejecutar. Resultado a la derecha. GET /_health POST /banco/user/_search { "query": { "match": { "nombre": "luis" } }, "size": 10 } POST /banco/transaction/_search { "aggs": { "total": { "sum": { "field": "monto" } } }, "size": 0 }
Disponible en /_console de cada instancia. Zero instalación. Zero configuración.
NeoDB es REST + JSON. No necesitas driver, SDK, librería ni ORM. Cualquier dispositivo o lenguaje con un cliente HTTP puede escribir, leer, buscar y agregar datos.
WiFi + HTTP POST = base de datos
Edge computing con ACID real
fetch() nativo, sin SDK
Python, Rust, Go, Node, C, Java...
// Un ESP32 escribiendo telemetría a NeoDB // Solo necesita WiFi y HTTP. Nada más. HTTPClient http; http.begin("http://neodb:7700/iot/sensor/temp-001"); http.addHeader("SLM-KEY", KEY); http.addHeader("Content-Type", "application/json"); int code = http.POST("{\"temp\":23.5,\"humidity\":65,\"ts\":1774477000}"); // 201 Created — ACID, durable, searchable, aggregatable
Sin drivers que mantener. Sin compatibilidad de versiones. Sin dependencias. Si tu dispositivo puede hacer un HTTP POST con JSON, ya puede usar NeoDB con todas sus capacidades: ACID, búsqueda, aggregations, vectores.
No decimos que NeoDB es mejor en todo. Estos son los hechos.
| PostgreSQL | Elasticsearch | MongoDB | NeoDB | |
|---|---|---|---|---|
| Full-text search | Lento | Excelente | Básico | Excelente (<1ms) |
| Vector search | pgvector ext | Limitado | Atlas Search | HNSW nativo |
| Aggregations | Lento en escala | Bueno | Bueno | Rápido (fast fields) |
| Consistencia ACID | Fuerte | Eventual | Configurable | Fuerte (fsync siempre) |
| Schema flexible | ALTER TABLE | Dinámico | Dinámico | Dinámico, zero downtime |
| Audit log | Manual | Manual | Manual | Nativo, automático |
| Crash recovery | WAL | Translog | Journal | WAL + auto-replay |
| PCI DSS | Manual | Plugin | Manual | Nativo (blind, audit, CIDR) |
| RAM min | ~256MB | 4-16GB | ~256MB | 128MB |
| Setup | Horas | Horas | Horas | 30 segundos |
| Oracle | MySQL | SQL Server | Supabase | NeoDB | |
|---|---|---|---|---|---|
| Full-text search | Oracle Text (complejo) | Muy básico | Básico | pg tsvector (lento) | Excelente (<1ms) |
| Vector search | No | No | No | pgvector ext | HNSW nativo |
| Aggregations | Requiere tuning | Lento en escala | Requiere tuning | SQL GROUP BY | Rápido (fast fields) |
| Consistencia ACID | Fuerte | Fuerte (InnoDB) | Fuerte | Fuerte (PostgreSQL) | Fuerte (fsync siempre) |
| Schema flexible | ALTER TABLE | ALTER TABLE | ALTER TABLE | Migraciones | Dinámico, zero downtime |
| Audit log | Enterprise ($$) | Plugin | Enterprise ($$) | Manual | Nativo, automático |
| Crash recovery | REDO log | InnoDB log | Transaction log | WAL | WAL + auto-replay |
| PCI DSS | TDE ($$) | Manual | TDE ($$) | Manual | Nativo (blind, audit, CIDR) |
| RAM min | 2-4GB | ~512MB | 2GB | ~512MB | 128MB |
| Setup | Días/semanas | Horas | Días | Minutos (cloud) | 30 segundos |
Dos bases de datos. Dos schemas. Un pipeline de sincronización que eventualmente se rompe. Cuando eso pasa, preguntas: ¿cuál tiene el dato real? NeoDB es una sola fuente de verdad.
| Supabase | NeoDB | |
|---|---|---|
| Full-text search | PostgreSQL tsvector | Tantivy <1ms |
| Aggregations | SQL GROUP BY | Nativos (sum, terms, histogram) |
| Vector search | pgvector ext | HNSW nativo |
| PCI | Manual | Nativo (blind, audit, CIDR) |
| Schema changes | Migraciones | Sin downtime |
Pinecone, Weaviate, Qdrant — solo hacen búsqueda vectorial. ¿Necesitas transacciones? Agrega PostgreSQL. ¿Búsqueda de texto? Agrega Elasticsearch. ¿Analítica? Agrega ClickHouse. Son 4 sistemas. NeoDB hace los 4. Un binario. Una factura.
PostgreSQL: ACID sí, búsqueda necesita ES.
Elasticsearch: Búsqueda sí, ACID no.
NeoDB: ACID + búsqueda + dashboard. Todo inmediato.
Tradicional: PostgreSQL + ES + auditoría custom.
NeoDB: match + fuzzy + aggs + _audit. Un sistema.
Tradicional: PostgreSQL + ES + Pinecone + Redis.
NeoDB: text + vector + range + aggs. Un query.
NeoDB es una base de datos vectorizada. Almacena embeddings junto a tus datos transaccionales y los busca por similitud semántica. Sin Pinecone. Sin infraestructura extra. Sin otra factura.
# 1. Guarda tu documento con su embedding curl -X POST :7700/knowledge/article/1 \ -d '{"titulo":"Política de cancelación", "contenido":"El cliente tiene 48 horas para cancelar...", "embedding":[0.023, -0.041, 0.018, ...]}' # 2. Busca por significado (no por palabras) curl -X POST :7700/knowledge/article/_search \ -d '{"query":{"knn":{ "field":"embedding", "vector":[0.019, -0.038, ...], "k":5, "min_score":0.7}}}' # 3. Los resultados van a tu LLM como contexto # NeoDB no sabe de LLMs. Solo guarda y busca vectores. # Tú eliges el modelo. Hoy OpenAI, mañana Ollama. NeoDB no cambia.
NeoDB es agnóstica. No genera embeddings. No depende de ningún LLM. Solo almacena arrays de números y los busca por similitud matemática. De dónde vengan esos números es decisión tuya.
El motor de storage es RocksDB — usado por Facebook, Uber, Netflix, CockroachDB. El motor de búsqueda es Tantivy — Apache Lucene reescrito en Rust, la misma base que usa Elasticsearch pero 2x más rápido y sin JVM. Lo usa Brave Search en producción. El lenguaje es Rust — adoptado por AWS, Microsoft, Google, el kernel de Linux. Lo nuevo es la integración.
Porque eventualmente tus datos en Elasticsearch van a diferir de los de PostgreSQL. Y vas a pasar semanas descubriendo cuál tiene la razón. Con NeoDB hay una sola fuente de verdad. Siempre.
1.1 millones de documentos en 60 segundos. Búsqueda full-text en <1ms. SUM de 500K transacciones en 14ms. 21,000 escrituras/segundo. En un solo nodo con 128MB de RAM.
Cada escritura hace fsync al WAL antes de responder. Si el proceso muere, el WAL recovery completa las operaciones pendientes. Si el servidor pierde energía, el dato está en disco. Pruébalo: inserta un documento, haz kill -9 al proceso, reinicia. Tu documento está ahí.
El DSL JSON de NeoDB maneja: combinaciones booleanas (AND/OR/NOT), rangos numéricos y de fechas, búsqueda full-text con relevancia, fuzzy (tolerancia a typos), geo por radio, vectores por similitud, wildcards, y aggregations con sub-aggregations. Todo en un request. Y lo que SQL no puede: búsqueda de texto en <1ms sobre 100 millones de registros.
En NeoDB el middleware hace los JOINs — y resulta que es más rápido. Haces 2-3 queries paralelos a NeoDB (cada uno en <1ms) y ensamblas en tu middleware con la lógica de negocio que ya tienes. En SQL un JOIN de 3 tablas con millones de filas puede tomar segundos. En NeoDB son 3 requests paralelos de <1ms cada uno.
{"query":{"bool":{"must":[{"term":{"active":true}},{"range":{"balance":{"gt":1000}}}]}},"sort":[{"name":"asc"}]}
Misma lógica, sintaxis JSON. Y a diferencia de SQL, también puedes buscar texto, agregar aggregations, y filtrar por geo o vectores en el mismo query.
Agrega campos nuevos en caliente con PATCH /_schema. Sin ALTER TABLE. Sin migraciones. Sin downtime. Sin bloquear lecturas ni escrituras. Los documentos existentes siguen funcionando — los campos nuevos simplemente no existen en los viejos. Sin schema (modo dinámico), aceptas cualquier JSON sin declarar nada.
NeoDB no usa punto flotante para números. El tipo number[n] almacena como entero escalado: 25.10 con number[2] se guarda como 2510 (i64). Aritmética exacta. Sin IEEE 754. Sin redondeo. Si mandas 3 decimales a un campo de 2, el motor rechaza con error. No inventa, no redondea, no trunca.
NeoDB fue diseñado desde el día uno con PCI DSS v4.0 en mente. El tipo blind hace que el PAN nunca toque el disco (solo hash BLAKE3 irreversible). El audit log registra cada operación de forma inmutable. SLM-KEY con CIDR binding asegura que una credencial robada no sirve fuera de las IPs autorizadas. Field masking elimina campos sensibles por key. Tenemos un documento completo mapeando cada requerimiento PCI.
En v1, cada documento es atómico por separado. Para operaciones que involucran múltiples documentos, el middleware maneja la coordinación — que es donde vive tu lógica de negocio de todas formas. El update_by_query permite actualizar miles de documentos en una sola operación atómica con scripts.
Guías completas para cada caso de uso.
Referencia completa de todos los endpoints REST
Embeddings, búsqueda semántica, integración con LLMs
Guía de integración para herramientas de IA
Configuración, backup, monitoreo y mejores prácticas
Las decisiones de arquitectura y sus razones
Dev tools embebido en cada instancia. Como Kibana Dev Tools — escribe queries, explora datos, monitorea el motor. Accesible en /_console de tu servidor.