polyglot

Polyglot es una interfaz uniforme para 18 bases de datos en 9 categorías, utilizable como biblioteca de Python/Java o como servidor MCP para LLMs, con protecciones integradas.

GitHub

Documentación

Polyglot

Una interfaz uniforme para muchas bases de datos — utilizable como biblioteca y como servidor Model Context Protocol (MCP) para LLMs, tanto en Python como en Java.

Polyglot te ofrece un conjunto único y consistente de operaciones — list_tables, run_query, explain_query, execute, copy_data, y más — que se comportan igual en motores relacionales, de documentos, clave-valor, de columnas anchas, de objetos, de grafos, vectoriales, de series temporales, de búsqueda y de almacén de datos. Una biblioteca central respalda tanto las herramientas MCP como la API importable, por lo que nunca divergen.

Un proyecto de código abierto independiente, impulsado por la comunidad, publicado bajo la licencia Apache 2.0.

El problema

Cada base de datos habla su propio idioma. En el momento en que una aplicación — o un agente LLM — necesita más de una, te toca lidiar con un controlador, lenguaje de consulta, esquema de autenticación, forma de resultados y historial de seguridad diferentes para cada una. Ese costo se multiplica por cada base de datos que tocas, y nuevamente por cada lenguaje en el que escribes y cada herramienta LLM que expones.

Sin Polyglot — cada motor es su propia integración personalizada:

flowchart LR
    App["Your app / LLM agent"]
    App -->|"psycopg · SQL"| PG[(PostgreSQL)]
    App -->|"pymongo · BSON filters"| MG[(MongoDB)]
    App -->|"redis-py · commands"| RD[(Redis)]
    App -->|"boto3 · S3 API"| S3[(S3)]
    App -->|"bolt · Cypher"| NEO[(Neo4j)]
    App -->|"REST · vector search"| QD[(Qdrant)]
    App -->|"…a new SDK each time"| ETC[(…9 more)]

Cada flecha es código separado para construir, asegurar y mantener — sin límites compartidos en el tamaño de los resultados, sin reglas consistentes de solo lectura/destructivas, sin salida uniforme.

Con Polyglot — una interfaz uniforme (y un conjunto de salvaguardas) frente a todos ellos:

flowchart LR
    App["Your app / LLM agent"] ==>|"one API · 12 MCP tools"| P{{Polyglot}}
    P --> PG[(PostgreSQL)]
    P --> MG[(MongoDB)]
    P --> RD[(Redis)]
    P --> S3[(S3)]
    P --> NEO[(Neo4j)]
    P --> QD[(Qdrant)]
    P --> ETC[(…14 engines,<br/>9 categories)]

Destacados

Una interfaz, 14 motores probados en vivo en 9 categorías (18 motores implementados en total; la categoría de almacén y algunos motores gestionados/con licencia están implementados pero necesitan credenciales en la nube para probarse). list_tables, run_query, explain_query, execute, copy_data, … se comportan igual en todas partes.
Biblioteca y servidor MCP desde un mismo núcleo. Llámalo desde código, o deja que un LLM lo maneje — comportamiento idéntico, porque ambos envuelven el mismo DatabaseCore.
Seguro por defecto. Solo lectura a menos que una conexión opte por lo contrario; las operaciones destructivas requieren confirmación explícita; los resultados están limitados; las columnas de PII se enmascaran; las credenciales nunca llegan al modelo.
Dos lenguajes, un contrato. Python y Java exponen herramientas MCP byte-idénticas — una puerta de enlace Java es un reemplazo directo de la de Python.

# the same call, whatever the engine underneath
db.run_query("warehouse", "SELECT ...")          # a SQL warehouse
db.run_query("cache", "GET session:42")          # Redis
db.copy_data("shop", "orders", "orders_archive") # any engine, same signature

"¿Qué clientes se dieron de baja el mes pasado?" — un LLM conectado a Polyglot responde eso contra Postgres, Mongo o BigQuery sin que escribas pegamento por base de datos.

Comenzar

Quiero…	Ir a
Usarlo desde Python (biblioteca o servidor MCP)	python/README.md
Usarlo desde Java (biblioteca o servidor MCP)	java/README.md
Probarlo (incl. un script en lenguaje natural)	TESTING.md
Contribuir	CONTRIBUTING.md

¿Cuándo debería usar esto?

Elige según quién está conduciendo:

La biblioteca (polyglot-core) — cuando el código es el consumidor: ETL y migraciones, una capa de acceso a datos que abarca varios almacenes, endpoints de administración/informes, trabajos por lotes. Tipado, programático, sin LLM involucrado.
El servidor MCP (polyglot-mcp) — cuando un LLM o agente es el consumidor: acceso conversacional a datos en Claude Desktop/Code, Cursor, etc.; flujos de trabajo agénticos que inspeccionan, consultan y mueven datos; acceso gobernado para no ingenieros.

Ambos comparten el mismo DatabaseCore, por lo que el comportamiento y las salvaguardas son idénticos ya sea que los active una llamada a función o un modelo de lenguaje.

Arquitectura

flowchart TD
    subgraph Consumers
        A[LLM via MCP client]
        B[Application code]
    end
    A -->|MCP tools over stdio/HTTP| G[polyglot-mcp<br/>MCP gateway]
    B -->|import| C
    G --> C[polyglot-core<br/>DatabaseCore + ConnectionRegistry]
    C --> S[Security guardrails<br/>read-only · destructive-confirm · row caps · redaction]
    C --> D{DatabaseAdapter<br/>one per engine}
    D --> E1[(Relational)]
    D --> E2[(Document)]
    D --> E3[(Key-value)]
    D --> E4[(Wide-column)]
    D --> E5[(Object)]
    D --> E6[(Graph / Vector)]
    D --> E7[(Time-series)]
    D --> E8[(Search)]
    D --> E9[(Warehouse)]

La puerta de enlace es un enrutador en proceso: un servidor MCP que carga adaptadores como bibliotecas y despacha cada llamada al backend correcto mediante un nombre connection. Las puertas de enlace de Python y Java exponen el mismo contrato de herramientas (nombres, argumentos y formas de resultados idénticos) y son reemplazos directos entre sí.

Bases de datos compatibles

Las operaciones universales funcionan en todos los motores. Leyenda — ✅ probado en vivo en el stack de Docker · ⚠️ implementado, aún no probado (necesita un proceso q con licencia o credenciales en la nube) · — aún no implementado en ese lenguaje (hoja de ruta).

Categoría	Motores	Python	Java
Relacional	PostgreSQL, MySQL/MariaDB, SQLite	✅	✅
Relacional (gestionado)	GCP Cloud SQL	⚠️	⚠️
Documento	MongoDB	✅	✅
Documento	CouchDB	✅	✅
Clave-valor	Redis	✅	✅
Clave-valor	Amazon DynamoDB	✅	✅
Columna ancha	Cassandra / ScyllaDB	✅	✅
Almacén de objetos	S3 / MinIO	✅	✅
Grafo	Neo4j	✅	✅
Vectorial	Qdrant	✅	✅
Series temporales	TimescaleDB, InfluxDB	✅	✅
Series temporales	kdb+ / q	⚠️	—
Búsqueda	OpenSearch / Elasticsearch	✅	✅
Almacén de datos	BigQuery, Snowflake	⚠️	—

Java tiene paridad total en todos los motores probables con Docker — 14 motores, verificados por el conjunto de pruebas de Java. kdb+ y los almacenes en la nube son la hoja de ruta de Java.

AWS S3 real no necesita un adaptador separado — el adaptador S3/MinIO probado habla directamente con AWS; solo omite endpoint_url y proporciona credenciales de AWS.

Salvaguardas de seguridad

Solo lectura por defecto. Las escrituras requieren allow_write en la conexión.
Las operaciones destructivas requieren cuidado adicional. DELETE / DROP / TRUNCATE / UPDATE-sin-WHERE (y los equivalentes de cada motor), además de copy_data con mode='replace' (que limpia el objetivo primero), requieren tanto allow_delete como un confirm_destructive=true explícito.
Las lecturas siguen siendo lecturas. run_query acepta solo lecturas; los adaptadores SQL las ejecutan dentro de una transacción de solo lectura revertida en el servidor, por lo que un CTE que modifica datos o un EXPLAIN ANALYZE DELETE que se escapa de la clasificación aún no puede escribir.
Límites de resultados. Las lecturas se limitan al max_rows de la conexión.
Redacción de PII. redact_columns se enmascaran en la salida de lectura.
Sin credenciales para el modelo. Las conexiones están pre-registradas; el LLM solo las referencia por nombre.

Las salvaguardas viven en el núcleo y se aplican de manera idéntica a la biblioteca y al servidor MCP, en ambos lenguajes.

Estructura del repositorio

polyglot/                       (monorepo)
├── python/                     Python implementation → PyPI
│   ├── polyglot-core/          the library
│   ├── polyglot-mcp/           the MCP server
│   └── tests/
├── java/                       Java implementation → Maven Central (dev.polyglot)
│   ├── polyglot-core/          the library
│   └── polyglot-mcp/           the MCP server
├── examples/                   SHARED: docker-compose stack, seed data, connection configs
├── README.md                   (this file)
├── ANALYSIS.md · TESTING.md · PUBLISHING.md
├── CONTRIBUTING.md · CODE_OF_CONDUCT.md · LICENSE
└── .mcp.json                   attaches the server to Claude Code sessions

Los nombres de los paquetes son idénticos en todos los lenguajes: PyPI polyglot-core / polyglot-mcp, y Maven dev.polyglot:polyglot-core / dev.polyglot:polyglot-mcp (el groupId de DNS inverso proporciona unicidad).

Rutas absolutas en configuraciones: .mcp.json, examples/claude_desktop_config.json, y la entrada sqlite_notes en examples/connections.json contienen rutas absolutas específicas de la máquina (el intérprete, POLYGLOT_CONFIG, y el archivo SQLite). Si clonas a una ubicación diferente, actualiza esas rutas y recrea el .venv.