Proporciona un plano de control de datos para que los agentes de IA puedan adquirir, validar, aterrizar y consultar datos a través de una única interfaz MCP.
También conocido como datris/datris-platform-oss, datris-platform-oss, datris-mcp-server
- Stars
- 14
- Herramientas
- —
- Descargas, 30 días
- 3156
- Última versión
- 1.58.2
- Último commit
- 13 nov 2026
- Licencia
- Apache-2.0
¿Qué es Datris MCP?
Proporciona un plano de control de datos para que los agentes de IA puedan adquirir, validar, aterrizar y consultar datos a través de una única interfaz MCP.
Resumen generado a partir del README del proyecto
Acerca del MCP server de Datris
Datris actúa como un plano de control de datos diseñado para que los agentes de IA gestionen todo el ciclo de vida de los datos mediante una única interfaz. Proporciona un punto de entrada MCP unificado con 90 herramientas que permiten a los agentes adquirir, validar, aterrizar y consultar datos sin necesidad de integraciones individuales para cada origen o destino. El sistema funciona junto a tus almacenes de datos y lakes actuales en lugar de reemplazarlos, asegurando que los datos fluyan hacia tus almacenes preferidos como PostgreSQL, MongoDB, Snowflake o diversas bases de datos vectoriales.
Los usuarios pueden desplegar la plataforma localmente, on-premise o en cualquier entorno de nube usando Docker. La configuración requiere una clave de proveedor de IA de servicios como Anthropic, OpenAI, Grok, Azure OpenAI o Amazon Bedrock. La seguridad se gestiona mediante credenciales gestionadas por vault, lo que significa que los agentes hacen referencia a los secretos por su nombre en lugar de poseer las claves reales. Esta arquitectura utiliza contenedores aislados para ejecutar scripts generados por IA para la extracción de datos, validación de calidad y transformaciones, manteniendo protegido el entorno principal.
Qué puedes hacer con él
- 1Adquisición de datos automatizadaUn agente puede crear un tap de datos personalizado simplemente describiendo la fuente en lenguaje natural.
- 2Validación de datos en lenguaje naturalLos desarrolladores pueden instruir a una IA para aplicar reglas de calidad de datos usando descripciones sencillas en inglés.
- 3Gestión segura de credencialesPuedes permitir que los agentes accedan a bases de datos sensibles sin exponer nunca las claves de API reales al agente en sí.
- 4Consulta de datos conversacionalLos usuarios pueden recuperar conjuntos de datos específicos haciendo preguntas en lenguaje natural en lugar de escribir SQL complejo.
Escrito a partir del README del proyecto. Cada caso de uso se verifica con una cita del mismo.
Cómo instalar Datris MCP
Formatos verificados el 10 nov 2026Añadir a CursorAñadir a GooseInstalar Datris MCP en Claude Code
$ claude mcp add --env 'DATRIS_API_URL=<DATRIS_API_URL>' --env 'DATRIS_API_KEY=<YOUR_DATRIS_API_KEY>' datris-platform-oss -- uvx datris-mcp-serverInstalar Datris MCP en Cursor
~/.cursor/mcp.json
{
"mcpServers": {
"datris-platform-oss": {
"command": "uvx",
"args": [
"datris-mcp-server"
],
"env": {
"DATRIS_API_URL": "<DATRIS_API_URL>",
"DATRIS_API_KEY": "<YOUR_DATRIS_API_KEY>"
}
}
}
}Instalar Datris MCP en VS Code
.vscode/mcp.json
{
"servers": {
"datris-platform-oss": {
"type": "stdio",
"command": "uvx",
"args": [
"datris-mcp-server"
],
"env": {
"DATRIS_API_URL": "<DATRIS_API_URL>",
"DATRIS_API_KEY": "<YOUR_DATRIS_API_KEY>"
}
}
}
}Instalar Datris MCP en VS Code CLI
$ code --add-mcp '{"name":"datris-platform-oss","type":"stdio","command":"uvx","args":["datris-mcp-server"],"env":{"DATRIS_API_URL":"<DATRIS_API_URL>","DATRIS_API_KEY":"<YOUR_DATRIS_API_KEY>"}}'Instalar Datris MCP en Claude Desktop
claude_desktop_config.json
{
"mcpServers": {
"datris-platform-oss": {
"command": "uvx",
"args": [
"datris-mcp-server"
],
"env": {
"DATRIS_API_URL": "<DATRIS_API_URL>",
"DATRIS_API_KEY": "<YOUR_DATRIS_API_KEY>"
}
}
}
}Instalar Datris MCP en Codex
$ codex mcp add datris-platform-oss --env 'DATRIS_API_URL=<DATRIS_API_URL>' --env 'DATRIS_API_URL=<DATRIS_API_URL>' --env 'DATRIS_API_KEY=<YOUR_DATRIS_API_KEY>' --env 'DATRIS_API_KEY=<YOUR_DATRIS_API_KEY>' -- uvx datris-mcp-serverInstalar Datris MCP en Codex config.toml
~/.codex/config.toml
[mcp_servers.datris-platform-oss] command = "uvx" args = ["datris-mcp-server"] [mcp_servers.datris-platform-oss.env] DATRIS_API_URL = "<DATRIS_API_URL>" DATRIS_API_KEY = "<YOUR_DATRIS_API_KEY>"
Instalar Datris MCP en Gemini CLI
$ gemini mcp add -s user -e 'DATRIS_API_URL=<DATRIS_API_URL>' -e 'DATRIS_API_URL=<DATRIS_API_URL>' -e 'DATRIS_API_KEY=<YOUR_DATRIS_API_KEY>' -e 'DATRIS_API_KEY=<YOUR_DATRIS_API_KEY>' datris-platform-oss uvx -- datris-mcp-serverInstalar Datris MCP en Gemini settings.json
~/.gemini/settings.json
{
"mcpServers": {
"datris-platform-oss": {
"command": "uvx",
"args": [
"datris-mcp-server"
],
"env": {
"DATRIS_API_URL": "<DATRIS_API_URL>",
"DATRIS_API_KEY": "<YOUR_DATRIS_API_KEY>"
}
}
}
}Configuración
DATRIS_API_URLObligatorioURL of the Datris server API (default http://localhost:8080)
DATRIS_API_URLObligatorioURL of the Datris server API (default http://localhost:8080)
DATRIS_API_KEYSecretoAPI key for the Datris server (only when USE_API_KEYS=true)
DATRIS_API_KEYSecretoAPI key for the Datris server (only when USE_API_KEYS=true)
ANTHROPIC_API_KEYEMBEDDING_PROVIDERPOSTGRES_ENABLEDTEI_ENABLED
| Nombre | Descripción | Tipo |
|---|---|---|
| DATRIS_API_URL | URL of the Datris server API (default http://localhost:8080) | Obligatorio |
| DATRIS_API_URL | URL of the Datris server API (default http://localhost:8080) | Obligatorio |
| DATRIS_API_KEY | API key for the Datris server (only when USE_API_KEYS=true) | Secreto |
| DATRIS_API_KEY | API key for the Datris server (only when USE_API_KEYS=true) | Secreto |
| ANTHROPIC_API_KEY | — | |
| EMBEDDING_PROVIDER | — | |
| POSTGRES_ENABLED | — | |
| TEI_ENABLED | — |
Verificaciones automáticas
Ejecutado 12 nov 2026Informe completo →Pasó nuestras verificaciones automáticas. Esto no es una auditoría de seguridad: lee el código y dale al servidor el acceso más limitado que necesite. Cómo funcionan las verificaciones
- Repositorio de origen vinculado y accesibleAprobado
- Licencia de código abierto (OSI)Aprobado
- Commit o lanzamiento en el último añoAprobado
- El nombre del paquete no es similar a un paquete popularAprobado
- El endpoint remoto usa HTTPSNo verificado
- Las herramientas destructivas están etiquetadasNo verificado
- Sin instrucciones ocultas para el modeloAprobado
- No hay avisos críticos en el paquete ni en sus dependenciasAprobado
README
Ver en GitHubDatris — The Data Control Plane for AI Agents
datris.ai · Documentation · MCP Registry · PyPI
⭐ If Datris is useful to you, star the repo — it helps other people find it.
Agents ask Datris for data. Datris finds it, acquires it, validates it, lands it in the stores you already run, and returns it with provenance — over MCP, without ever holding your keys. It sits beside your warehouse and lake; it doesn't replace them.
See it in 90 seconds — describe the data you need, and the Assistant builds the tap, runs it, and lands the data:
https://github.com/user-attachments/assets/4f03dc12-e9d7-4f93-8ba4-d712ab7d3733
🔊 Sound is off by default — click the speaker icon in the player.
Why Datris?
https://github.com/user-attachments/assets/ba3de886-1413-4d92-92bb-99018cfaff38
🔊 Sound is off by default — click the speaker icon in the player, or watch on YouTube.
Your agents already acquire, validate, and load data. Without a control plane, they do it badly. Datris puts that work behind one governed surface:
- One MCP door — 90 tools behind a single MCP server. Claude, Cursor, and any MCP-compatible agent learn one interface instead of 90 integrations
- Vault-brokered credentials — the agent references a secret by name and never holds a key; agent-written code runs in an isolated container with no keys inside
- Scoped keys, approval gates, audit log — each agent gets its own API key limited to the capabilities you grant; an agent policy decides per action whether an agent runs it, waits for a person to approve, or is refused; an audit log, once you turn it on (
USE_AUDIT_LOG=true), records who did what, best effort by default and without loss in strict mode - Every run recorded — job state and row counts for every run, provenance on its rows with stamping on; every generated script versioned in git
- Durable state — pipelines and sync bookmarks live in the platform, not the chat, so regenerating a script never loses its place
- The operating loop — Acquire (AI-generated taps) → Validate (plain-English rules) → Land (multi-destination pipelines) → Observe (provenance and job state) → Explain & Repair (AI error explanation), with the same audit trail every time once the audit log is on (see strict mode)
- Self-host anywhere — on-prem, any cloud, or your laptop; 100% open-source infrastructure (MinIO, PostgreSQL, MongoDB, Kafka, Vault), Apache-2.0, no managed service
Quick Start
You need Docker and one AI provider key (Anthropic, OpenAI, Grok, Azure OpenAI,
or Amazon Bedrock). This pulls pre-built images and runtime files, seeds a
.env, and starts the stack into ./datris — no git checkout required. The
installer asks for the key:
curl -fsSL https://get.datris.ai/install.sh | sh
Installing from a coding agent or a CI job with no terminal attached? Export the key first (ANTHROPIC_API_KEY, OPENAI_API_KEY, or another provider's): the installer asks nothing and reads it from the environment. Then check http://localhost:8080/api/v1/version answers before going on. Full steps: Install for Agents.
Minimal install (laptop-friendly). The default stack runs about ten
containers and the bundled embedding server downloads a 2.2 GB model on first
boot. None of that is required. Three settings in .env cut it to nine small
containers, no download, and roughly 3.5 GB of memory (4 GB of Docker memory
is enough; the full stack wants 8 GB):
TEI_ENABLED=0 # skip the local embedding server and its 2.2 GB download
EMBEDDING_PROVIDER=openai # semantic search via OpenAI (needs OPENAI_API_KEY); omit if you have no OpenAI key
POSTGRES_ENABLED=0 # optional: skip bundled Postgres; MongoDB stays as the destination
The installer sets the first two when you choose OpenAI embeddings. The datris server itself runs on a 2 GB heap by default. Details: Installation → Minimal install.
The
install.shinstaller is a POSIX shell script (macOS/Linux). On Windows, run it from WSL2 or Git Bash, or use the single-file Compose option below, which works natively in PowerShell.
A fully self-contained Compose file — the init scripts and config are inlined, so nothing else is needed (requires Docker Compose ≥ 2.23):
# macOS / Linux
curl -O https://get.datris.ai/docker-compose.standalone.yml
ANTHROPIC_API_KEY=sk-ant-... docker compose -f docker-compose.standalone.yml up -d
# Windows (PowerShell) — use curl.exe, and set the key with $env:
curl.exe -O https://get.datris.ai/docker-compose.standalone.yml
$env:ANTHROPIC_API_KEY="sk-ant-..."
docker compose -f docker-compose.standalone.yml up -d
git clone https://github.com/datris/datris-platform-oss.git
cd datris-platform-oss
cp .env.example .env # Add your ANTHROPIC_API_KEY and/or OPENAI_API_KEY (or the AZURE_OPENAI_* trio, XAI_API_KEY, or AI_PROVIDER=bedrock)
docker compose up -d
UI: http://localhost:4200 · API: http://localhost:8080
Connect an AI Agent
Add to your MCP client config (Claude Desktop, Claude Code, Cursor, etc.). With the Docker stack running, the npx mcp-remote stdio bridge connects to the bundled MCP server on port 3000 — your client appears in the Datris UI Agent Monitor tab with live tool-call streaming:
{
"mcpServers": {
"datris": {
"command": "npx",
"args": ["-y", "mcp-remote", "http://localhost:3000/sse", "--transport", "sse-only"]
}
}
}
Paste-and-go for the default local setup — no API key required when USE_API_KEYS=false (the OSS default). If your instance enables auth (USE_API_KEYS=true or multi-tenant), append "--header", "x-api-key:<your-key>" to the args array. The Configuration → Connect Your Agent page generates the snippet for you and adds the header automatically when you paste your key.
Requires Node.js on your PATH (brew install node). For a stdio alternative without Docker, or full Claude Desktop / Claude Code / Cursor walkthroughs, see Configuring Claude.
To teach the coding agents in your own projects (Claude Code, Codex, and similar) to use Datris for data work, install the datris-platform skill from skills/ — see Agent Skill.
CLI
brew tap datris/tap
brew install datris
datris ingest data.csv --dest postgres
datris ingest sales.csv --ai-validate "prices > 0" --ai-transform "convert dates to YYYY/MM/DD"
datris query "SELECT * FROM sales"
datris search "quarterly revenue" --store pgvector --collection financial_docs
datris tap create "Fetch S&P 500 daily prices from yfinance" --pipeline stocks
datris taps
datris doctor # operational self-check; prints the fix for every finding
What It Does
Source (Tap / File Upload / MinIO Event / Database Pull / Kafka)
→ Preprocessor (optional REST endpoint)
→ Field Protection (pseudonymize, mask, redact, encrypt, or drop sensitive fields)
→ Data Quality (AI rules, header validation, schema validation)
→ Transformation (AI transformation, destination schema)
→ Destinations (in parallel):
PostgreSQL, MongoDB, Snowflake, Databricks, Microsoft SQL Server / Azure SQL,
MinIO / S3 (Parquet, ORC, Apache Iceberg), Kafka, ActiveMQ,
REST Endpoint, Qdrant, Weaviate, Milvus, Chroma, pgvector
→ Notifications (ActiveMQ topic)
AI-Powered Features
| Feature | Description |
|---|---|
| MCP Server | 90 tools for AI agents — pipeline CRUD, upload, query, search, profiling, taps, catalogs, provenance |
| Taps | Describe a source in plain English — AI generates a Python script that fetches it on demand or on a schedule, run in an isolated container |
| Assistant | Conversational tap and pipeline creation, operations, and configuration in the UI |
| AI Data Quality | Plain English validation rules — AI generates and runs a validation script |
| AI Transformation | Plain English transformations — AI generates and runs a transformation script |
| AI Schema Generation | Upload a file, get a complete pipeline config |
| AI Data Profiling | Upload a file, get statistics + suggested validation rules |
| AI Error Explanation | Job failures explained in plain English |
| Natural Language Query | Ask questions in English, get SQL results |
| RAG Pipeline | Chunk, embed, and search across 5 vector databases |
| Field Protection | Pseudonymize, mask, redact, encrypt, or drop sensitive fields before any AI stage or destination sees them |
Supported Formats
CSV, JSON, XML, Excel, PDF, Word (DOCX), PowerPoint, HTML, email, EPUB, plain text
AI Providers
Anthropic Claude (Opus 5.5 default for chat and CodeGen) · OpenAI (GPT-5.6 Sol default for chat and CodeGen) · Azure OpenAI (bring your Azure resource; models by deployment name) · Amazon Bedrock (Claude through your AWS account — IAM auth, AWS billing, IAM-role support with zero stored keys) · Grok (xAI's models through their OpenAI-compatible API) · Ollama (local models, optional). Embeddings via OpenAI text-embedding-3-small (recommended when you have an OpenAI key), Azure OpenAI, the bundled TEI sidecar (BAAI/bge-m3 — fully local, no API key), or Ollama.
Architecture
| Service | Purpose |
|---|---|
| MinIO | S3-compatible object store for file staging and data output |
| PostgreSQL | Default structured destination, also hosts pgvector for RAG |
| MongoDB | Configuration store, job status tracking, metadata |
| ActiveMQ | File notification queue, pipeline event notifications |
| HashiCorp Vault | Secrets management (database credentials, API keys) |
| TEI | Text Embeddings Inference sidecar (BAAI/bge-m3) — local vector embeddings when you're not using OpenAI embeddings |
| Apache Kafka | Optional streaming source and destination |
| Apache Spark | Local Spark for writing Parquet, ORC, and Iceberg tables to MinIO / S3 |
| Tap runner | Isolated container that runs AI-generated tap scripts with no platform credentials and no route to internal services |
| CodeGen runner | Second isolated container, built from the same image, that runs AI-generated data-quality and transformation scripts |
| MCP server | Bundled MCP endpoint (SSE on port 3000) for AI agents |
Documentation
Full documentation at docs.datris.ai or locally at docs/. Going to production? Start with Security Architecture and SECURITY.md.
License
Apache License 2.0. See NOTICE for attribution.
Preguntas sobre Datris MCP
¿Cómo agrego Datris MCP a Claude Code?
Ejecuta claude mcp add --env 'DATRIS_API_URL=<DATRIS_API_URL>' --env 'DATRIS_API_KEY=<YOUR_DATRIS_API_KEY>' datris-platform-oss -- uvx datris-mcp-server en tu terminal. Añade --scope user para que esté disponible en todos los proyectos.
¿Cómo agrego Datris MCP a Cursor?
Abre ~/.cursor/mcp.json y añade el servidor en mcpServers, usando la configuración de Cursor que se muestra en la sección de instalación de arriba.
¿Cómo gestiona Datris la seguridad y las credenciales?
Datris utiliza credenciales gestionadas mediante vault para que los agentes hagan referencia a los secretos por su nombre sin llegar a poseer las claves reales, ejecutando el código en contenedores aislados.
¿Puedo alojar Datris por mi cuenta?
Sí, Datris es infraestructura 100% open-source que puedes alojar localmente, en cualquier nube o en tu propia laptop.
¿Cómo conecto un agente de IA como Claude o Cursor a Datris?
Puedes añadir el Datris MCP server a la configuración de tu cliente usando el comando npx mcp-remote para conectarte al endpoint SSE incluido.