polyglot

O Polyglot é uma interface uniforme para 18 bancos de dados em 9 categorias, utilizável como biblioteca Python/Java ou servidor MCP para LLMs, com proteções integradas.

GitHub

Experimente este MCPPatrocinado

Documentação

Polyglot

Uma interface uniforme para muitos bancos de dados — utilizável como biblioteca e como servidor Model Context Protocol (MCP) para LLMs, tanto em Python quanto em Java.

O Polyglot oferece um conjunto único e consistente de operações — list_tables, run_query, explain_query, execute, copy_data e mais — que se comportam da mesma forma em mecanismos relacionais, de documentos, chave-valor, colunas largas, objetos, grafos, vetores, séries temporais, busca e data warehouses. Uma única biblioteca principal dá suporte tanto às ferramentas MCP quanto à API importável, para que nunca haja divergência.

Um projeto open-source independente, conduzido pela comunidade, lançado sob a licença Apache 2.0.

O problema

Cada banco de dados fala sua própria língua. No momento em que um aplicativo — ou um agente de LLM — precisa de mais de um, você fica responsável por um driver, linguagem de consulta, esquema de autenticação, formato de resultado e estratégia de segurança diferentes para cada um. Esse custo se multiplica por cada banco de dados que você utiliza, e novamente por cada linguagem em que você escreve e por cada ferramenta de LLM que você expõe.

Sem o Polyglot — cada mecanismo é uma integração personalizada própria:

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 seta é um código separado para construir, proteger e manter — sem limites compartilhados de tamanho de resultado, sem regras consistentes de somente leitura/destrutivas, sem saída uniforme.

Com o Polyglot — uma interface uniforme (e um conjunto de proteções) na frente de todos eles:

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)]

Destaques

Uma interface, 14 mecanismos testados ao vivo em 9 categorias (18 mecanismos implementados no total; a categoria de data warehouse e alguns mecanismos gerenciados/licenciados estão implementados, mas precisam de credenciais em nuvem para testar). list_tables, run_query, explain_query, execute, copy_data, … comportam-se da mesma forma em todos os lugares.
Biblioteca e servidor MCP a partir de um único núcleo. Chame pelo código ou deixe um LLM conduzi-lo — comportamento idêntico, porque ambos envolvem o mesmo DatabaseCore.
Seguro por padrão. Somente leitura, a menos que uma conexão opte por isso; operações destrutivas exigem confirmação explícita; os resultados são limitados; colunas de PII são mascaradas; credenciais nunca chegam ao modelo.
Duas linguagens, um contrato. Python e Java expõem ferramentas MCP byte-idênticas — um gateway Java é um substituto direto para o gateway 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

"Quais clientes cancelaram no mês passado?" — um LLM conectado ao Polyglot responde a isso contra Postgres, Mongo ou BigQuery sem que você escreva código de integração por banco.

Comece agora

Eu quero…	Vá para
Usar a partir do Python (biblioteca ou servidor MCP)	python/README.md
Usar a partir do Java (biblioteca ou servidor MCP)	java/README.md
Testar (incluindo um script em linguagem natural)	TESTING.md
Contribuir	CONTRIBUTING.md

Quando devo usar isso?

Escolha com base em quem está conduzindo:

A biblioteca (polyglot-core) — quando código é o consumidor: ETL e migrações, uma camada de acesso a dados que abrange vários armazenamentos, endpoints de administração/relatórios, trabalhos em lote. Tipada, programática, sem envolvimento de LLM.
O servidor MCP (polyglot-mcp) — quando um LLM ou agente é o consumidor: acesso conversacional a dados no Claude Desktop/Code, Cursor, etc.; fluxos de trabalho agênticos que inspecionam, consultam e movem dados; acesso governado para não-engenheiros.

Ambos compartilham o mesmo DatabaseCore, portanto o comportamento e as proteções são idênticos seja uma chamada de função ou um modelo de linguagem que os acione.

Arquitetura

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)]

O gateway é um roteador em processo: um servidor MCP que carrega adaptadores como bibliotecas e despacha cada chamada para o backend correto por um nome de connection. Os gateways Python e Java expõem o mesmo contrato de ferramentas (nomes, argumentos e formatos de resultado idênticos) e são substitutos diretos um do outro.

Bancos de dados suportados

Operações universais funcionam em todos os mecanismos. Legenda — ✅ testado ao vivo na pilha Docker · ⚠️ implementado, ainda não testado (precisa de um processo q licenciado ou credenciais em nuvem) · — ainda não implementado nessa linguagem (roadmap).

Categoria	Mecanismos	Python	Java
Relacional	PostgreSQL, MySQL/MariaDB, SQLite	✅	✅
Relacional (gerenciado)	GCP Cloud SQL	⚠️	⚠️
Documento	MongoDB	✅	✅
Documento	CouchDB	✅	✅
Chave-valor	Redis	✅	✅
Chave-valor	Amazon DynamoDB	✅	✅
Colunas largas	Cassandra / ScyllaDB	✅	✅
Armazenamento de objetos	S3 / MinIO	✅	✅
Grafo	Neo4j	✅	✅
Vetor	Qdrant	✅	✅
Séries temporais	TimescaleDB, InfluxDB	✅	✅
Séries temporais	kdb+ / q	⚠️	—
Busca	OpenSearch / Elasticsearch	✅	✅
Data warehouse	BigQuery, Snowflake	⚠️	—

Java tem paridade total em todos os mecanismos testáveis via Docker — 14 mecanismos, verificados pela suíte de testes Java. kdb+ e os data warehouses em nuvem são o roadmap do Java.

AWS S3 real não precisa de adaptador separado — o adaptador S3/MinIO testado fala diretamente com a AWS; basta omitir endpoint_url e fornecer credenciais da AWS.

Proteções de segurança

Somente leitura por padrão. Gravações exigem allow_write na conexão.
Operações destrutivas exigem cuidado extra. DELETE / DROP / TRUNCATE / UPDATE-sem-WHERE (e os equivalentes de cada mecanismo), além de copy_data com mode='replace' (que limpa o destino primeiro), exigem tanto allow_delete quanto um confirm_destructive=true explícito.
Leituras permanecem leituras. run_query aceita apenas leituras; os adaptadores SQL as executam dentro de uma transação somente leitura no lado do servidor, com rollback, para que um CTE de modificação de dados ou EXPLAIN ANALYZE DELETE que escape da classificação ainda não possa gravar.
Limites de resultados. Leituras são limitadas ao max_rows da conexão.
Mascaramento de PII. redact_columns são mascarados na saída de leitura.
Sem credenciais para o modelo. Conexões são pré-registradas; o LLM apenas as referencia por nome.

As proteções vivem no núcleo e se aplicam de forma idêntica à biblioteca e ao servidor MCP, em ambas as linguagens.

Estrutura do repositório

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

Os nomes dos pacotes são idênticos entre as linguagens: PyPI polyglot-core / polyglot-mcp e Maven dev.polyglot:polyglot-core / dev.polyglot:polyglot-mcp (o groupId reverse-DNS garante exclusividade).

Caminhos absolutos em configurações: .mcp.json, examples/claude_desktop_config.json e a entrada sqlite_notes em examples/connections.json contêm caminhos absolutos específicos da máquina (o interpretador, POLYGLOT_CONFIG e o arquivo SQLite). Se você clonar para um local diferente, atualize esses caminhos e recrie o .venv.