meryn-mcp 0.1.0__tar.gz

meryn_mcp-0.1.0/.gitignore

@@ -0,0 +1,153 @@
+# docs/ (SOLO la de la raíz) entero: notas de trabajo, no fuente. Estaban listados
+# de a uno (schema, MASTER_PLAN, TESTS_SPEC…) y cada archivo nuevo se colaba al
+# repo por olvido. Ojo: CLAUDE.md apunta a docs/db-region-y-latencia.md y dos
+# tests citan docs/{auditoria-2026-08,db-region-y-latencia}.md — en un clon
+# limpio esos punteros no resuelven. El contenido sigue en el historial.
+# Ancla a la raíz con `/`: sin eso, el patrón también se comía apps/docs/,
+# content/docs/ y static/docs/img/ — la documentación de producto, que SÍ es
+# fuente y tiene que commitearse.
+/docs
+
+.idea
+.vscode
+*.code-workspace
+*.pyc
+*~
+.venv
+venv
+db.sqlite3
+.sass-cache/
+celerybeat-schedule
+mktlab/localsettings.py
+mktlab/local.py
+static_root/
+node_modules/
+.vite/
+openapitools.json
+media/
+_dist/
+.env
+.env.production
+.DS_Store
+.direnv
+.envrc
+# compiled static files are built in dev/deploy
+static/css/
+static/js/*
+# fuentes y demás assets que emite Vite con hash en el nombre
+static/assets/
+# ...except the hand-written canvas JS, which is source, not a Vite build output
+!static/js/canvas/
+# Las librerías de terceros las copia `npm run vendor` desde node_modules
+# (scripts/vendor-static.mjs); son build output, no se commitean.
+static/js/vendor/
+
+# Environment files with credentials
+.env.local
+.env.production
+.env.staging
+.env.development
+
+# Credential files
+credentials/
+secrets/
+*.key
+*.pem
+service-account*.json
+*credential*.json
+*secret*.json
+
+# Database files
+*.db
+*.sqlite3
+
+# Log files
+*.log
+logs.json
+logs/
+*.log.*
+
+# Temporary files
+*.tmp
+*.temp
+*.bak
+*.backup
+
+
+# Pendings
+zzz.txt
+
+# Volcados de logs de los workers. El script que los genera vive en
+# scripts/fetch_worker_logs.sh y SÍ se versiona; su salida, no.
+*_logs.txt
+
+# R API folder
+apiR/
+
+# Robyn local development files
+robyn.csv
+tmp/robyn_outputs/
+*.csv.tmp
+
+# Charts Svelte
+charts/
+!templates/charts/
+
+# Development tools cache and config
+# `.claude/skills/` SÍ va a git: CLAUDE.md las referencia por ruta, así que si no
+# viajan, un clone fresco tiene punteros rotos. Se excluyen dos cosas y sólo dos:
+#   - settings.local.json: permisos de ESTA máquina, no del proyecto.
+#   - worktrees/: son git worktrees (cada uno con su propio `.git`), así que git
+#     los ve como repos EMBEBIDOS. No se llevaría los 2,8 GB —git no recursa en un
+#     repo anidado— pero los agregaría como gitlink: una entrada de submódulo que
+#     apunta a un commit que nadie puede clonar, y rompe el checkout de quien clone.
+.claude/settings.local.json
+.claude/worktrees/
+.ruff_cache/
+.clinerules
+
+# Teams
+teams.txt
+pegasus_example_team_apps/
+
+# Stripe
+stripe.md
+
+# Robyn hyperparameters default
+robyn_hyperparameter_default.ods
+
+# Table names
+TABLA_RENAMING_PLAN.md
+
+# Meridian Documentation
+meridian_documentation
+
+# Meridian plots (local reference only, not for GitHub)
+plots_meridian/
+
+# Claude Ignore
+.claudeignore
+
+# EDA
+eda.py
+
+# Log del worker local (make demo)
+.demo-worker.log
+
+# Artefactos del barrido de QA (scripts/qa/) — snapshots, capturas y reportes
+qa-runs/
+
+# Documentación y notebooks de los frameworks MMM, pineados a la versión que
+# corre en prod. Los baja `scripts/sync_framework_docs.py` desde los repos
+# upstream: son ~320 MB reconstruibles, igual que static/js/vendor/.
+# El índice de qué archivo contesta qué pregunta SÍ va trackeado.
+# ⚠️ `reference/*` y no `reference/`: git no re-incluye un archivo si el
+# directorio padre está excluido — la negación no falla, simplemente no hace nada.
+reference/*
+!reference/INDEX.md
+
+# La lista de prospectos de `scripts/prospectos.py`: nombres, emails y empleadores de
+# gente real, sacados de sus perfiles públicos de GitHub. No es fuente y no queremos
+# datos personales en git — menos todavía en un clon ajeno.
+prospectos.csv
+prospectos.log

meryn_mcp-0.1.0/PKG-INFO

@@ -0,0 +1,138 @@
+Metadata-Version: 2.5
+Name: meryn-mcp
+Version: 0.1.0
+Summary: MCP server for the meryn API — read your MMM results and launch runs from Claude
+Project-URL: Homepage, https://meryn.ai
+Project-URL: Documentation, https://meryn.ai/docs/api/mcp/
+Project-URL: API reference, https://meryn.ai/api/v1/docs/
+Author-email: meryn <hi@meryn.ai>
+License-Expression: MIT
+Keywords: marketing-mix-modeling,mcp,meridian,mmm,pymc-marketing,robyn
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Requires-Python: >=3.10
+Requires-Dist: mcp<3,>=2.0
+Description-Content-Type: text/markdown
+
+# meryn MCP
+
+Connect Claude to your [meryn](https://meryn.ai) account: read your MMM results and launch
+runs without leaving the conversation.
+
+The server runs **on your machine**, talks to the meryn API over HTTPS, and holds nothing —
+your key lives in your own config.
+
+## Install
+
+```bash
+claude mcp add meryn -e MERYN_API_KEY=mk_… -- uvx meryn-mcp
+```
+
+Or, in any MCP client's config file:
+
+```json
+{
+  "mcpServers": {
+    "meryn": {
+      "command": "uvx",
+      "args": ["meryn-mcp"],
+      "env": {
+        "MERYN_API_KEY": "mk_...",
+        "MERYN_BASE_URL": "https://meryn.ai"
+      }
+    }
+  }
+}
+```
+
+`MERYN_BASE_URL` is optional; it defaults to `https://meryn.ai`.
+
+**The key** is the one you create in your team's settings → **API keys**
+([how](https://meryn.ai/docs/api/api-keys/)). It is shown once, so copy it then. Give it
+`read` unless you want the assistant to be able to launch runs.
+
+⚠️ **API access is part of the plan.** Professional and Enterprise include it; Free does
+not. Without it the first tool call returns
+`403: This team plan does not include API access.`
+
+## What it can do
+
+| | |
+|---|---|
+| **Read** | projects, datasets, mappings and periods; models with their metrics and readiness verdict; the progress, logs and run history; every chart dataset and the finer-grained result tables; EDA runs; the budget allocator's split by channel and by market, and its efficiency |
+| **Launch** | create a model on an existing period, run it, cancel it; create and run a budget optimisation |
+
+What it deliberately **doesn't** do: upload and map a CSV. That step stays in the web app,
+where a person confirms how the file was interpreted — which column is the date, what each
+column means, what got normalised.
+
+## Three things worth knowing
+
+**The knobs aren't written into the server.** `list_engine_params` fetches them live from
+the API, with each one's type, default, bounds and help text. They're the same rows that
+draw the modals in the app, so they can't go stale — and it's the first place to look
+before building a `config`.
+
+**Anything that costs compute asks first.** `run_model` and `run_allocator` start
+containers: tens of minutes of compute and one of your plan's concurrent-run slots. The
+server **refuses** them without an explicit `confirm`, so an assistant can't fire one in
+passing. That's a guard in the code, not a hint in the description.
+
+**Retries don't duplicate runs.** Every POST carries an `Idempotency-Key` derived from the
+operation and its arguments, so if the assistant retries because it didn't see the
+response, the API returns what it already created instead of launching a second run.
+
+## How to read the numbers
+
+The API returns **raw** values with a `units` map beside them, and that is on purpose: an
+assistant doing arithmetic on `"12.3%"` gets it wrong two steps later, in a budget
+recommendation. Four rules that matter:
+
+- `fraction` is 0–1 and `percent` is 0–100 — both appear in the same response, so read the
+  unit instead of guessing from the field name;
+- a `null` means *not measured*, never zero — an organic channel's ROI is `null` because it
+  has no spend, and averaging it as zero drags the average down;
+- anything listed in `not_applicable` **does not exist** for that engine (Robyn does no
+  MCMC, so it has no r-hat). That is not missing data;
+- on the readiness verdict, `pending` and `not_evaluated` are **not** green: the first means
+  it hasn't been computed yet, the second that it ran and could not measure anything.
+
+⚠️ **And on charts, watch `national_only`.** When it is set, the rows are **national**, not
+the market you asked for — either because that chart cannot be cut by market (Meridian
+estimates one decay per channel, shared across markets) or because the model was trained
+before we started saving it per market. Reporting them as that market's is the mistake the
+field exists to prevent.
+
+## Not hosted anywhere
+
+There is no remote MCP endpoint to point at, and that is deliberate for now: stdio on your
+own machine means the key never leaves it and there is no third party in the path. A hosted
+version with OAuth is something we will build when someone needs it.
+
+## Links
+
+- [Using the API](https://meryn.ai/docs/api/using-the-api/) — authentication, pagination,
+  retries, and the same four rules in more detail
+- [API reference](https://meryn.ai/api/v1/docs/) — generated from the API itself
+
+---
+
+<!-- Lo de abajo es para quien trabaja en el repo, no para quien instala el paquete; va
+     acá porque este README ES la página de PyPI y partirlo en dos archivos deja uno de
+     los dos sin leer. -->
+
+### Para el repo
+
+| Archivo | Qué es |
+|---|---|
+| `meryn_mcp/__init__.py` | el cliente HTTP y el catálogo de tools. **Sin dependencias**, y es lo que prueba la suite (`apps/api/tests/test_mcp.py`) |
+| `meryn_mcp/servidor.py` | el cableado del SDK de MCP. Lo mínimo que no se puede probar sin el paquete `mcp` |
+
+⚠️ **Es un paquete y no dos módulos sueltos**, y el motivo aparece recién al publicar: el
+wheel dejaba un top-level llamado `servidor` en el `site-packages` de cualquiera que lo
+instalara. Adentro del repo daba igual; distribuido, no.
+
+Publicar: `uv build && uv publish` desde `clients/mcp/`. ⚠️ Subir la versión en
+`pyproject.toml` antes — PyPI no deja re-subir una versión ya publicada.

meryn_mcp-0.1.0/README.md

@@ -0,0 +1,120 @@
+# meryn MCP
+
+Connect Claude to your [meryn](https://meryn.ai) account: read your MMM results and launch
+runs without leaving the conversation.
+
+The server runs **on your machine**, talks to the meryn API over HTTPS, and holds nothing —
+your key lives in your own config.
+
+## Install
+
+```bash
+claude mcp add meryn -e MERYN_API_KEY=mk_… -- uvx meryn-mcp
+```
+
+Or, in any MCP client's config file:
+
+```json
+{
+  "mcpServers": {
+    "meryn": {
+      "command": "uvx",
+      "args": ["meryn-mcp"],
+      "env": {
+        "MERYN_API_KEY": "mk_...",
+        "MERYN_BASE_URL": "https://meryn.ai"
+      }
+    }
+  }
+}
+```
+
+`MERYN_BASE_URL` is optional; it defaults to `https://meryn.ai`.
+
+**The key** is the one you create in your team's settings → **API keys**
+([how](https://meryn.ai/docs/api/api-keys/)). It is shown once, so copy it then. Give it
+`read` unless you want the assistant to be able to launch runs.
+
+⚠️ **API access is part of the plan.** Professional and Enterprise include it; Free does
+not. Without it the first tool call returns
+`403: This team plan does not include API access.`
+
+## What it can do
+
+| | |
+|---|---|
+| **Read** | projects, datasets, mappings and periods; models with their metrics and readiness verdict; the progress, logs and run history; every chart dataset and the finer-grained result tables; EDA runs; the budget allocator's split by channel and by market, and its efficiency |
+| **Launch** | create a model on an existing period, run it, cancel it; create and run a budget optimisation |
+
+What it deliberately **doesn't** do: upload and map a CSV. That step stays in the web app,
+where a person confirms how the file was interpreted — which column is the date, what each
+column means, what got normalised.
+
+## Three things worth knowing
+
+**The knobs aren't written into the server.** `list_engine_params` fetches them live from
+the API, with each one's type, default, bounds and help text. They're the same rows that
+draw the modals in the app, so they can't go stale — and it's the first place to look
+before building a `config`.
+
+**Anything that costs compute asks first.** `run_model` and `run_allocator` start
+containers: tens of minutes of compute and one of your plan's concurrent-run slots. The
+server **refuses** them without an explicit `confirm`, so an assistant can't fire one in
+passing. That's a guard in the code, not a hint in the description.
+
+**Retries don't duplicate runs.** Every POST carries an `Idempotency-Key` derived from the
+operation and its arguments, so if the assistant retries because it didn't see the
+response, the API returns what it already created instead of launching a second run.
+
+## How to read the numbers
+
+The API returns **raw** values with a `units` map beside them, and that is on purpose: an
+assistant doing arithmetic on `"12.3%"` gets it wrong two steps later, in a budget
+recommendation. Four rules that matter:
+
+- `fraction` is 0–1 and `percent` is 0–100 — both appear in the same response, so read the
+  unit instead of guessing from the field name;
+- a `null` means *not measured*, never zero — an organic channel's ROI is `null` because it
+  has no spend, and averaging it as zero drags the average down;
+- anything listed in `not_applicable` **does not exist** for that engine (Robyn does no
+  MCMC, so it has no r-hat). That is not missing data;
+- on the readiness verdict, `pending` and `not_evaluated` are **not** green: the first means
+  it hasn't been computed yet, the second that it ran and could not measure anything.
+
+⚠️ **And on charts, watch `national_only`.** When it is set, the rows are **national**, not
+the market you asked for — either because that chart cannot be cut by market (Meridian
+estimates one decay per channel, shared across markets) or because the model was trained
+before we started saving it per market. Reporting them as that market's is the mistake the
+field exists to prevent.
+
+## Not hosted anywhere
+
+There is no remote MCP endpoint to point at, and that is deliberate for now: stdio on your
+own machine means the key never leaves it and there is no third party in the path. A hosted
+version with OAuth is something we will build when someone needs it.
+
+## Links
+
+- [Using the API](https://meryn.ai/docs/api/using-the-api/) — authentication, pagination,
+  retries, and the same four rules in more detail
+- [API reference](https://meryn.ai/api/v1/docs/) — generated from the API itself
+
+---
+
+<!-- Lo de abajo es para quien trabaja en el repo, no para quien instala el paquete; va
+     acá porque este README ES la página de PyPI y partirlo en dos archivos deja uno de
+     los dos sin leer. -->
+
+### Para el repo
+
+| Archivo | Qué es |
+|---|---|
+| `meryn_mcp/__init__.py` | el cliente HTTP y el catálogo de tools. **Sin dependencias**, y es lo que prueba la suite (`apps/api/tests/test_mcp.py`) |
+| `meryn_mcp/servidor.py` | el cableado del SDK de MCP. Lo mínimo que no se puede probar sin el paquete `mcp` |
+
+⚠️ **Es un paquete y no dos módulos sueltos**, y el motivo aparece recién al publicar: el
+wheel dejaba un top-level llamado `servidor` en el `site-packages` de cualquiera que lo
+instalara. Adentro del repo daba igual; distribuido, no.
+
+Publicar: `uv build && uv publish` desde `clients/mcp/`. ⚠️ Subir la versión en
+`pyproject.toml` antes — PyPI no deja re-subir una versión ya publicada.

meryn_mcp-0.1.0/meryn_mcp/__init__.py

@@ -0,0 +1,663 @@
+"""El cliente de la API de meryn y el catálogo de tools del MCP. **Sin dependencias.**
+
+Está separado de `servidor.py` —que es el cableado del SDK de MCP— por una razón
+práctica: así esto se puede importar y probar desde la suite de Django, que no tiene (ni
+debe tener) el paquete `mcp` instalado. El servidor web no es un cliente de MCP; meterle
+esa dependencia sería hacerla viajar a producción para nada.
+
+Usa sólo `urllib` de la stdlib. No es purismo: el MCP lo instala **el cliente** en su
+máquina, y cada dependencia es una cosa más que puede chocar con lo que ya tenga.
+
+## ⚠️ El catálogo de tools se DECLARA; la ayuda de los parámetros se DERIVA
+
+Las dos mitades, y las dos a propósito:
+
+- **El catálogo es una decisión de producto**: qué diez cosas tiene sentido que un agente
+  haga, no una proyección mecánica de los veinte endpoints. Y las descripciones van en
+  inglés escritas para un agente, no los docstrings internos. Lo que sí hay es un
+  guardián (`test_mcp.py`) que exige que cada `path` de acá exista en el esquema OpenAPI:
+  una ruta renombrada rompe un test, no la instalación de un cliente.
+- **Las perillas se derivan en vivo** de `GET /engines/{key}/params/`, que las saca de
+  `mmm_param*` — las mismas filas que dibujan los modales, con sus cotas, su default y su
+  `help_text` (que `params.E003` ya exige). Escribirlas acá sería una sexta capa de
+  defaults, y quedaría vieja el día que alguien edite una fila desde el admin.
+
+## ⚠️ Lo que cuesta plata se marca y pide confirmación EXPLÍCITA
+
+`run_model` y `run_allocator` lanzan contenedores de Cloud Run: cada uno son decenas de
+minutos de cómputo y un slot de la cuota del plan. Un agente las va a llamar solo, así
+que no alcanza con avisarlo en la descripción — **el server las rechaza sin
+`confirm=true`**. Es una guarda nuestra, no una sugerencia al modelo.
+
+Y además van con `Idempotency-Key`: un reintento del agente no tiene que lanzar una
+segunda corrida. La key la genera este cliente a partir de la operación y sus argumentos,
+así que dos llamadas idénticas colapsan en una sin que el agente tenga que acordarse.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import urllib.error
+import urllib.parse
+import urllib.request
+from dataclasses import dataclass, field
+
+#: Tope duro de items por respuesta. Un agente que se trae las 2806 filas de un mapeo al
+#: contexto es un modo de falla real: la ventana se llena de datos que no va a usar y se
+#: pierde el hilo de la tarea. La API ya pagina; acá se pide chico por defecto.
+PAGINA = 25
+
+TIMEOUT = 60
+
+
+class ErrorDeApi(Exception):
+    """Un error que vale la pena mostrarle al agente tal cual."""
+
+    def __init__(self, status, cuerpo):
+        self.status = status
+        self.cuerpo = cuerpo
+        # ⚠️ **`error` Y `detail`.** Nuestros endpoints usan `error`; los 401/403/429 los
+        # arma DRF y usan `detail`. Leyendo sólo el primero, el agente recibía
+        # `HTTP 403: None` en vez de *"This API key is read-only"* — o sea el único caso
+        # en que el mensaje le dice qué hacer. Se vio corriéndolo contra el server.
+        detalle = (cuerpo.get('error') or cuerpo.get('detail')) if isinstance(cuerpo, dict) else cuerpo
+        super().__init__(f'HTTP {status}: {detalle}')
+
+
+@dataclass(frozen=True)
+class Tool:
+    nombre: str
+    descripcion: str
+    metodo: str
+    #: Con marcadores `{}` para los argumentos de ruta: `models/{model_id}/metrics/`.
+    path: str
+    #: Nombre → descripción. Los que aparecen en `path` son de ruta; el resto, query (en
+    #: GET) o cuerpo (en POST).
+    argumentos: dict = field(default_factory=dict)
+    obligatorios: tuple = ()
+    #: ¿Lanza cómputo? Si sí, exige `confirm=true`.
+    cuesta_computo: bool = False
+    #: ¿El cliente puede rellenar `limit` solo cuando el agente lo omite?
+    #:
+    #: ⚠️ **`False` en las tools cuyo dataset ES un gráfico**, y no es una preferencia: su
+    #: descripción dice *"omitilo para traer la serie entera"*, así que rellenarlo hacía
+    #: que **seguir la instrucción produjera el recorte**. Un agente pedía el ajuste de un
+    #: modelo de 104 semanas, recibía 25 filas y reportaba "predice bien hasta junio". La
+    #: respuesta trae `count` y `truncated`, pero el agente no tiene motivo para mirarlos:
+    #: pidió la serie completa. `_recorte` del lado de la API está escrito para esto mismo.
+    pagina_por_defecto: bool = True
+
+    def argumentos_de_ruta(self):
+        return tuple(p.split('}')[0] for p in self.path.split('{')[1:])
+
+
+#: ⚠️ El argumento que toda tool costosa exige. Se declara una vez para que la guarda y
+#: el esquema que ve el agente no puedan decir cosas distintas.
+CONFIRMACION = 'confirm'
+_AYUDA_CONFIRMACION = (
+    'Must be true. Launching costs real compute (tens of minutes of Cloud Run) and uses '
+    'one of the team plan concurrent-run slots, so it is never implicit: ask the user '
+    'before setting it.'
+)
+
+TOOLS: tuple[Tool, ...] = (
+    Tool(
+        nombre='list_engines',
+        descripcion=(
+            'List the MMM engines available (Robyn, Meridian, PyMC): which ones support '
+            'per-market (geo) data and which have a budget allocator. Start here when you '
+            'do not know what the account can do.'
+        ),
+        metodo='GET',
+        path='engines/',
+    ),
+    Tool(
+        nombre='list_engine_params',
+        descripcion=(
+            'The full configuration surface of one engine: every knob with its type, '
+            'default, bounds and help text, plus the effort levels and the prior families '
+            'it offers. This is the schema of the `config` object that create_model '
+            'accepts — read it before building a config, because it is served live from '
+            'the database and changes without a release.'
+        ),
+        metodo='GET',
+        path='engines/{engine}/params/',
+        argumentos={'engine': 'Engine key, e.g. "robyn", "meridian" or "pymc".'},
+        obligatorios=('engine',),
+    ),
+    Tool(
+        nombre='list_projects',
+        descripcion='List the projects visible to this key, newest configuration first.',
+        metodo='GET',
+        path='projects/',
+        argumentos={'limit': 'Max projects to return.', 'offset': 'Skip this many.'},
+    ),
+    Tool(
+        nombre='get_project',
+        descripcion=(
+            'One project with its node graph: the datasets, mappings, periods, models and '
+            'allocators it holds, and which engines its level allows.'
+        ),
+        metodo='GET',
+        path='projects/{project_id}/',
+        argumentos={'project_id': 'Numeric project id.'},
+        obligatorios=('project_id',),
+    ),
+    Tool(
+        nombre='list_models',
+        descripcion=(
+            'List trained or configured models. Filter by `engine`, `status` '
+            '("configured", "processing", "completed", "error") or `project`.'
+        ),
+        metodo='GET',
+        path='models/',
+        argumentos={
+            'engine': 'Only this engine.',
+            'status': 'Only this status.',
+            'project': 'Only models of this project id.',
+            'limit': 'Max models to return.',
+            'offset': 'Skip this many.',
+        },
+    ),
+    Tool(
+        nombre='get_model',
+        descripcion='One model: its status, the period it trained on, its data frequency and its allocators.',
+        metodo='GET',
+        path='models/{model_id}/',
+        argumentos={'model_id': 'Model UUID.'},
+        obligatorios=('model_id',),
+    ),
+    Tool(
+        nombre='get_model_metrics',
+        descripcion=(
+            'Fit and attribution metrics for a model, as raw numbers plus a `units` map '
+            'saying how to read each one. IMPORTANT: values flagged "fraction" are 0-1, '
+            'not percentages; a `null` means not measured (never zero); and anything '
+            'listed in `not_applicable` does not exist for that engine (Robyn has no MCMC, '
+            'so it has no r-hat). Do not convert or fill these in.'
+        ),
+        metodo='GET',
+        path='models/{model_id}/metrics/',
+        argumentos={
+            'model_id': 'Model UUID.',
+            'split': 'One of "all", "train", "validation", "test".',
+            'geo': 'A market name, or "total" for the national row.',
+            'sol_id': 'Robyn only: a specific Pareto solution. Defaults to the selected one.',
+        },
+        obligatorios=('model_id',),
+    ),
+    Tool(
+        nombre='get_model_readiness',
+        descripcion=(
+            'Whether this model is fit to make decisions with: a green/amber/red verdict '
+            'and the findings behind it. IMPORTANT: `state` can be "pending" (the verdict '
+            'has not been computed yet) or "not_evaluated" (it ran and could not measure '
+            'anything). Neither of those means the model is good — do not report a model '
+            'as sound without an "evaluated" state.'
+        ),
+        metodo='GET',
+        path='models/{model_id}/readiness/',
+        argumentos={'model_id': 'Model UUID.'},
+        obligatorios=('model_id',),
+    ),
+    Tool(
+        nombre='get_model_logs',
+        descripcion=(
+            'Current stage, elapsed time and the last worker log lines of a run. Use this '
+            'to follow a run you launched, or to find out why one failed. Pass `since` '
+            '(ISO timestamp) to get only what is new.'
+        ),
+        metodo='GET',
+        path='models/{model_id}/logs/',
+        argumentos={'model_id': 'Model UUID.', 'since': 'ISO timestamp; only newer lines.'},
+        obligatorios=('model_id',),
+    ),
+    Tool(
+        nombre='list_model_runs',
+        descripcion=(
+            'The last runs of a model: when each started and ended, and how it finished. '
+            'Use it to tell "this never ran" from "this failed three times" — and to see '
+            'how long a run of this size takes before launching another.'
+        ),
+        metodo='GET',
+        path='models/{model_id}/runs/',
+        argumentos={'model_id': 'Model UUID.'},
+        obligatorios=('model_id',),
+    ),
+    Tool(
+        nombre='list_model_charts',
+        descripcion=(
+            'Which chart datasets a model has, and WHICH AXIS they cut on — read this '
+            'before asking for one, instead of guessing the parameter. `axis` is "geo" '
+            '(pass a market name), "sol_id" (Robyn, which has hundreds of Pareto '
+            'solutions but no markets) or null (nothing to choose). `national_only` lists '
+            'the charts that cannot be cut by market at all, with the reason.'
+        ),
+        metodo='GET',
+        path='models/{model_id}/charts/',
+        argumentos={
+            'model_id': 'Model UUID.',
+            'geo': 'Market name. Only for engines whose axis is "geo"; omit for national.',
+            'sol_id': 'Robyn only: a Pareto solution. Defaults to the one selected in the app.',
+        },
+        obligatorios=('model_id',),
+    ),
+    Tool(
+        nombre='get_model_chart',
+        descripcion=(
+            'One chart dataset as rows, with a `units` map and `null_means` next to them: '
+            'the contribution waterfall, the fit over time, response curves, adstock '
+            'decay, convergence, credible intervals, the decomposition. Call '
+            'list_model_charts first to see what this model has. IMPORTANT: if '
+            '`national_only` is set, the rows are NATIONAL and not the market you asked '
+            'for — say so rather than reporting them as that market. Values flagged '
+            '"fraction" are 0-1, and a `null` means not measured, never zero.'
+        ),
+        metodo='GET',
+        path='models/{model_id}/charts/{dataset}/',
+        argumentos={
+            'model_id': 'Model UUID.',
+            'dataset': 'Dataset name, from list_model_charts.',
+            'geo': 'Market name, for engines whose axis is "geo".',
+            'sol_id': 'Robyn only: a Pareto solution.',
+            'limit': 'Max rows. Omit to get the whole series — a truncated chart looks complete.',
+            'offset': 'Skip this many rows.',
+        },
+        obligatorios=('model_id', 'dataset'),
+        # La descripción promete la serie entera; el cliente no la puede recortar sola.
+        pagina_por_defecto=False,
+    ),
+    Tool(
+        nombre='list_model_results',
+        descripcion=(
+            'Which finer-grained result tables a model has. Use these when a chart is too '
+            'aggregated for the question: the waterfall sums over every date, so '
+            '"contribution of TV by week" is not in it, and the decomposition folds '
+            'intercept, trend and seasonality into one baseline series.'
+        ),
+        metodo='GET',
+        path='models/{model_id}/results/',
+        argumentos={'model_id': 'Model UUID.'},
+        obligatorios=('model_id',),
+    ),
+    Tool(
+        nombre='get_model_results',
+        descripcion=(
+            'One result table whole, with the market, the date and the Pareto solution as '
+            'COLUMNS rather than parameters — one call gets the cube and you group it '
+            'yourself. Paginated, so check `count` against what you received before '
+            'concluding anything about totals.'
+        ),
+        metodo='GET',
+        path='models/{model_id}/results/{family}/',
+        argumentos={
+            'model_id': 'Model UUID.',
+            'family': 'Family name, from list_model_results.',
+            'limit': 'Max rows per page.',
+            'offset': 'Skip this many.',
+        },
+        obligatorios=('model_id', 'family'),
+    ),
+    Tool(
+        nombre='list_eda',
+        descripcion=(
+            'The exploratory data analyses (EDA) in this account. EDA is not one of the '
+            'MMM engines — it checks a dataset BEFORE training — so it lives on its own '
+            'path and does not appear in list_models.'
+        ),
+        metodo='GET',
+        path='eda/',
+        argumentos={
+            'status': 'Filter by status, e.g. "completed".',
+            'limit': 'Max to return.',
+            'offset': 'Skip this many.',
+        },
+    ),
+    Tool(
+        nombre='list_eda_charts',
+        descripcion='Which EDA datasets a run has (series, correlations, VIF, cost share, lagged correlations).',
+        metodo='GET',
+        path='eda/{eda_id}/charts/',
+        argumentos={'eda_id': 'EDA UUID.', 'geo': 'Market name; omit for the aggregate.'},
+        obligatorios=('eda_id',),
+    ),
+    Tool(
+        nombre='get_eda_chart',
+        descripcion=(
+            'One EDA dataset as rows: the variables over time, the correlation pairs, the '
+            'VIF per variable with its reading, the cost share, or the lagged '
+            'correlations. Use this to judge whether a dataset is fit to train on — '
+            'collinearity and flat channels are what make a model unusable later. '
+            'IMPORTANT: omitting `geo` gives the AGGREGATE, which is computed on the panel '
+            'collapsed by date, not the sum of the markets.'
+        ),
+        metodo='GET',
+        path='eda/{eda_id}/charts/{dataset}/',
+        argumentos={
+            'eda_id': 'EDA UUID.',
+            'dataset': 'Dataset name, from list_eda_charts.',
+            'geo': 'Market name; omit for the aggregate.',
+            'limit': 'Max rows. Omit for the whole series.',
+            'offset': 'Skip this many.',
+        },
+        obligatorios=('eda_id', 'dataset'),
+        # La descripción promete la serie entera; el cliente no la puede recortar sola.
+        pagina_por_defecto=False,
+    ),
+    Tool(
+        nombre='get_allocator',
+        descripcion='A budget allocation: its scenario, budget and the national lift it found.',
+        metodo='GET',
+        path='allocators/{allocator_id}/',
+        argumentos={'allocator_id': 'Allocator UUID.'},
+        obligatorios=('allocator_id',),
+    ),
+    Tool(
+        nombre='get_allocator_channels',
+        descripcion=(
+            'The per-channel budget split of one market cut: current vs optimal spend and '
+            'response. Pass `geo` for a market; the default is the national row. The '
+            '`totals` object leaves a response at null when any channel is missing it — '
+            'that is not zero, and summing around it would present a partial as a total.'
+        ),
+        metodo='GET',
+        path='allocators/{allocator_id}/channels/',
+        argumentos={'allocator_id': 'Allocator UUID.', 'geo': 'Market name, or "total".'},
+        obligatorios=('allocator_id',),
+    ),
+    Tool(
+        nombre='get_allocator_efficiency',
+        descripcion=(
+            'Current vs optimized per metric, with the improvement — every market cut at '
+            'once, with `geo` as a column. IMPORTANT: read `total_means` before adding '
+            'anything up. In PyMC the `total` rows ARE the sum of the markets (it '
+            'optimises jointly); in Meridian each market is an independent optimisation '
+            'and its rows do NOT add up to the total.'
+        ),
+        metodo='GET',
+        path='allocators/{allocator_id}/efficiency/',
+        argumentos={
+            'allocator_id': 'Allocator UUID.',
+            'limit': 'Max rows per page.',
+            'offset': 'Skip this many.',
+        },
+        obligatorios=('allocator_id',),
+    ),
+    # ── Los tres pasos del flujo, que faltaban ────────────────────────────────
+    #
+    # ⚠️ Sin éstos, `create_model` pide un `period_id` que por MCP sólo se podía sacar
+    # leyendo el `object_id` de los nodos que devuelve `get_project` — o sea que el camino
+    # de escritura empezaba con una adivinanza.
+    Tool(
+        nombre='list_datasets',
+        descripcion='The uploaded CSVs of a project, with their row and column counts.',
+        metodo='GET',
+        path='projects/{project_id}/datasets/',
+        argumentos={
+            'project_id': 'Numeric project id.',
+            'limit': 'Max to return.',
+            'offset': 'Skip this many.',
+        },
+        obligatorios=('project_id',),
+    ),
+    Tool(
+        nombre='list_mappings',
+        descripcion=(
+            'The variable mappings of a dataset: which role each column plays, the date '
+            'range of the file and the frequency measured from it. Read this to know what '
+            'a model will actually train on.'
+        ),
+        metodo='GET',
+        path='datasets/{dataset_id}/mappings/',
+        argumentos={
+            'dataset_id': 'Numeric dataset id.',
+            'limit': 'Max to return.',
+            'offset': 'Skip this many.',
+        },
+        obligatorios=('dataset_id',),
+    ),
+    Tool(
+        nombre='list_periods',
+        descripcion=(
+            'The periods (date windows) defined on a mapping. A period id is what '
+            'create_model requires — the window decides which rows train, and it is asked '
+            'for explicitly rather than guessed.'
+        ),
+        metodo='GET',
+        path='mappings/{mapping_id}/periods/',
+        argumentos={
+            'mapping_id': 'Numeric mapping id.',
+            'limit': 'Max to return.',
+            'offset': 'Skip this many.',
+        },
+        obligatorios=('mapping_id',),
+    ),
+    Tool(
+        nombre='create_model',
+        descripcion=(
+            'Create a model on an existing period. It does NOT start training: the model '
+            'is left ready to run, so you can build and review a configuration safely. '
+            'Build `config` from list_engine_params; anything you omit takes the default '
+            'from the database. Upload and map a dataset in the web app first — this API '
+            'does not do that step.'
+        ),
+        metodo='POST',
+        path='models/create/',
+        argumentos={
+            'engine': 'Engine key.',
+            'period_id': 'Numeric id of the period (Experiment) to train on.',
+            'name': 'Optional name. A default naming the engine is used otherwise.',
+            'config': 'Object of knob → value, as described by list_engine_params.',
+        },
+        obligatorios=('engine', 'period_id'),
+    ),
+    Tool(
+        nombre='run_model',
+        descripcion=(
+            'Start training a configured model. COSTS COMPUTE: tens of minutes of Cloud '
+            'Run and one concurrent-run slot of the plan. Returns immediately; follow it '
+            'with get_model_logs. A model already running returns 409 — do not retry it.'
+        ),
+        metodo='POST',
+        path='models/{model_id}/run/',
+        argumentos={'model_id': 'Model UUID.', CONFIRMACION: _AYUDA_CONFIRMACION},
+        obligatorios=('model_id', CONFIRMACION),
+        cuesta_computo=True,
+    ),
+    Tool(
+        nombre='cancel_model_run',
+        descripcion=(
+            'Stop a queued or running model and leave it ready to run again. Cancelling is '
+            'a request, not a kill: the container can take a few seconds to stop, and it '
+            'saves nothing from the cancelled run.'
+        ),
+        metodo='POST',
+        path='models/{model_id}/cancel/',
+        argumentos={'model_id': 'Model UUID.'},
+        obligatorios=('model_id',),
+    ),
+    Tool(
+        nombre='create_allocator',
+        descripcion=(
+            'Create a budget allocation on a trained model. Does NOT run it. Which '
+            'scenarios exist, and which of them need a target instead of a budget, comes '
+            'from list_engine_params for `<engine>_allocator`.'
+        ),
+        metodo='POST',
+        path='allocators/create/',
+        argumentos={
+            'model_id': 'UUID of the trained model to optimise.',
+            'name': 'Name for this allocation.',
+            'start_date': 'ISO date of the optimisation window start.',
+            'end_date': 'ISO date of the window end.',
+            'optimization_scenario': 'Scenario key, e.g. "max_response" or "fixed_budget".',
+            'total_budget': 'Budget to allocate, for budget scenarios.',
+            'target_value': 'Target, for target scenarios.',
+            'optimize_by_geo': (
+                'Per-market optimisation. Meridian and PyMC only, and it means a different '
+                'thing in each: PyMC moves budget between markets, Meridian runs one '
+                'optimisation inside each.'
+            ),
+            'channel_constraints': 'Optional per-channel bounds envelope.',
+        },
+        obligatorios=('model_id', 'name', 'start_date', 'end_date'),
+    ),
+    Tool(
+        nombre='run_allocator',
+        descripcion=(
+            'Run a configured budget allocation. COSTS COMPUTE, though much less than training. Returns immediately.'
+        ),
+        metodo='POST',
+        path='allocators/{allocator_id}/run/',
+        argumentos={'allocator_id': 'Allocator UUID.', CONFIRMACION: _AYUDA_CONFIRMACION},
+        obligatorios=('allocator_id', CONFIRMACION),
+        cuesta_computo=True,
+    ),
+)
+
+POR_NOMBRE = {t.nombre: t for t in TOOLS}
+
+
+#: Los argumentos que NO son texto. Todo lo demás es `str`: los ids son UUID o enteros
+#: que viajan en la URL, y las fechas van en ISO.
+#:
+#: ⚠️ `config` tiene que ser **objeto** y no string. Declarado como string, un agente
+#: mandaría el JSON serializado y la API lo rechazaría — con un error sobre el tipo del
+#: campo, que no dice nada de cuál era el problema real.
+_TIPOS = {CONFIRMACION: bool, 'config': dict, 'channel_constraints': dict}
+
+
+#: El nombre con el que este paquete se instala. ⚠️ Es la pata frágil de `version()`: un
+#: typo acá no falla, **cae al fallback para siempre** y el server reporta `0+local` en
+#: producción sin que nadie se entere. Por eso es una constante y hay un test que la
+#: compara contra el `name` del `pyproject.toml`.
+PAQUETE = 'meryn-mcp'
+
+
+def version() -> str:
+    """La versión de este paquete, DERIVADA de su metadata.
+
+    ⚠️ Sin esto `MCPServer` arranca con `version=''` y el cliente, al conectar, muestra el
+    server sin versión — que es lo primero que se mira cuando algo no anda y hay que saber
+    qué está corriendo. Derivada y no escrita acá: un número a mano se desincroniza de
+    `pyproject.toml` en el primer release.
+
+    El fallback cubre correr el archivo sin instalar el paquete, donde no hay metadata que
+    leer. Dice `+local` a propósito: *"esto no es un release"* es información, y un `0.0.0`
+    inventado se leería como una versión de verdad.
+    """
+    from importlib.metadata import PackageNotFoundError
+    from importlib.metadata import version as _del_paquete
+
+    try:
+        return _del_paquete(PAQUETE)
+    except PackageNotFoundError:
+        return '0+local'
+
+
+def tipo_de(argumento: str) -> type:
+    """El tipo de un argumento de tool.
+
+    ⚠️ **Es lo único de la forma del esquema que vive acá.** El JSON Schema lo genera el
+    SDK de MCP a partir de la firma de la función (`servidor._fabricar`): hubo una versión
+    que además lo armaba a mano en este módulo, o sea **dos generadores del mismo
+    documento** — y el que el agente ve es el del SDK, así que el otro podía estar
+    equivocado sin que nada fallara. Quedó sólo la decisión que es nuestra, y probada.
+    """
+    return _TIPOS.get(argumento, str)
+
+
+class Cliente:
+    """HTTP contra `/api/v1/`. Una instancia por proceso."""
+
+    def __init__(self, base_url: str, api_key: str, timeout: int = TIMEOUT, abrir=None):
+        self.base = base_url.rstrip('/') + '/api/v1/'
+        self.api_key = api_key
+        self.timeout = timeout
+        # Inyectable para poder probar sin red. No es un `if testing`: es el único
+        # parámetro que el test cambia, y así el camino que se prueba es el real.
+        self._abrir = abrir or urllib.request.urlopen
+
+    def llamar(self, nombre: str, argumentos: dict) -> dict:
+        tool = POR_NOMBRE.get(nombre)
+        if tool is None:
+            raise ErrorDeApi(400, {'error': f'unknown tool {nombre!r}'})
+
+        argumentos = dict(argumentos or {})
+
+        # ⚠️ **La guarda de cómputo va ANTES del chequeo de obligatorios**, y el orden es
+        # el punto: `confirm` también es obligatorio, así que al revés la respuesta era
+        # *"missing required argument(s): ['confirm']"* y el mensaje que le dice al agente
+        # **que le pregunte al usuario** no se mostraba nunca. Se vio corriéndolo.
+        if tool.cuesta_computo and argumentos.get(CONFIRMACION) is not True:
+            # La guarda es NUESTRA, no una sugerencia en la descripción: el agente llama
+            # solo y acá cada llamada son decenas de minutos de cómputo facturado.
+            raise ErrorDeApi(
+                400,
+                {
+                    'error': (
+                        f'{nombre} launches real compute, so it needs confirm=true. Ask the user before launching.'
+                    )
+                },
+            )
+
+        # Va DESPUÉS de la guarda de cómputo (ver arriba) y ANTES de armar la ruta: los
+        # argumentos de ruta se saca con `pop`, así que uno ausente sería un `KeyError`.
+        faltan = [a for a in tool.obligatorios if argumentos.get(a) in (None, '')]
+        if faltan:
+            raise ErrorDeApi(400, {'error': f'missing required argument(s): {faltan}'})
+
+        path = tool.path
+        for arg in tool.argumentos_de_ruta():
+            path = path.replace('{' + arg + '}', urllib.parse.quote(str(argumentos.pop(arg))))
+        argumentos.pop(CONFIRMACION, None)
+
+        if tool.metodo == 'GET':
+            # Pedir chico por defecto SÓLO donde la tool declara paginar —un `limit` en
+            # un endpoint que no lo acepta sería un parámetro inventado— y sólo donde la
+            # tool lo PERMITE: ver `Tool.pagina_por_defecto`.
+            if 'limit' in tool.argumentos and tool.pagina_por_defecto:
+                argumentos.setdefault('limit', PAGINA)
+            query = {k: v for k, v in argumentos.items() if v not in (None, '')}
+            url = self.base + path + ('?' + urllib.parse.urlencode(query) if query else '')
+            return self._pedir('GET', url, None, None)
+
+        cuerpo = {k: v for k, v in argumentos.items() if v is not None}
+        return self._pedir('POST', self.base + path, cuerpo, clave_idempotente(nombre, path, cuerpo))
+
+    def _pedir(self, metodo, url, cuerpo, idempotency_key):
+        datos = json.dumps(cuerpo).encode() if cuerpo is not None else None
+        pedido = urllib.request.Request(url, data=datos, method=metodo)
+        pedido.add_header('Authorization', f'Bearer {self.api_key}')
+        pedido.add_header('Accept', 'application/json')
+        if datos is not None:
+            pedido.add_header('Content-Type', 'application/json')
+        if idempotency_key:
+            pedido.add_header('Idempotency-Key', idempotency_key)
+
+        try:
+            with self._abrir(pedido, timeout=self.timeout) as respuesta:
+                return json.loads(respuesta.read() or b'{}')
+        except urllib.error.HTTPError as e:
+            crudo = e.read()
+            try:
+                cuerpo_error = json.loads(crudo or b'{}')
+            except ValueError:
+                cuerpo_error = {'error': (crudo or b'').decode(errors='replace')[:500]}
+            raise ErrorDeApi(e.code, cuerpo_error) from None
+
+
+def clave_idempotente(nombre, path, cuerpo) -> str:
+    """Una key estable para `(tool, ruta, cuerpo)`.
+
+    ⚠️ **La genera el cliente y no el agente**, y es lo que hace que la protección exista
+    de verdad: un agente que reintenta porque no vio la respuesta manda exactamente los
+    mismos argumentos, así que la key coincide y la API devuelve lo que ya creó en vez de
+    lanzar una segunda corrida. Dejársela al agente sería confiar en que se acuerde.
+
+    Lleva el cuerpo ordenado: el mismo pedido serializado en otro orden tiene que dar la
+    misma key, o un reintento legítimo se leería como una operación nueva.
+    """
+    huella = json.dumps([nombre, path, cuerpo], sort_keys=True, default=str)
+    return 'mcp-' + hashlib.sha256(huella.encode()).hexdigest()[:32]

meryn_mcp-0.1.0/meryn_mcp/servidor.py

@@ -0,0 +1,107 @@
+"""El servidor MCP: cableado del SDK, y nada más.
+
+Todo lo que se puede probar vive en `meryn_mcp.py`, que no tiene dependencias. Acá queda
+sólo lo que no se puede probar sin el paquete `mcp` instalado. Si este archivo crece,
+algo se está escribiendo en el lugar equivocado.
+
+## ⚠️ El esquema de cada tool lo genera el SDK, no nosotros
+
+`MCPServer.add_tool` deriva el JSON Schema de la **firma** de la función, así que las
+funciones se fabrican desde el catálogo (`meryn_mcp.TOOLS`) con su firma y sus
+`Annotated[..., Field(description=...)]` puestos. Hubo una versión que además armaba el
+esquema a mano en `meryn_mcp.py`: dos generadores del mismo documento, y el que el agente
+ve es el del SDK — el otro se habría podido equivocar sin que nada fallara. Lo que quedó
+en el módulo puro es la única decisión que es nuestra y no del SDK: **qué tipo tiene cada
+argumento** (`meryn_mcp.tipo_de`), que sí está probada.
+
+## ⚠️ Verificado contra el SDK instalado, no de memoria
+
+La primera versión de este archivo usaba la API v1 (`@server.list_tools()`,
+`inputSchema`) y **no arrancaba**: el SDK está en 2.x, donde `FastMCP` pasó a ser
+`MCPServer`, las tools se registran por función y el campo es `input_schema`. Se descubrió
+corriéndolo, que es la única forma. Para correrlo a mano:
+
+    MERYN_API_KEY=mk_… MERYN_BASE_URL=https://meryn.ai python servidor.py
+"""
+
+from __future__ import annotations
+
+import asyncio
+import inspect
+import json
+import os
+import sys
+from typing import Annotated
+
+from mcp.server.mcpserver import MCPServer
+from meryn_mcp import TOOLS, Cliente, ErrorDeApi, tipo_de, version
+from pydantic import Field
+
+BASE_POR_DEFECTO = 'https://meryn.ai'
+
+servidor = MCPServer('meryn', version=version())
+_cliente_cache: Cliente | None = None
+
+
+def cliente() -> Cliente:
+    """El cliente HTTP, uno por proceso.
+
+    La key se lee en el primer uso y se falla con el motivo: sin esto el primer síntoma
+    sería un 401 en cada tool, que se lee como "la key no sirve" en vez de "no hay key".
+    """
+    global _cliente_cache
+    if _cliente_cache is None:
+        key = os.environ.get('MERYN_API_KEY')
+        if not key:
+            sys.exit('MERYN_API_KEY no está seteada. Es la key que meryn emitió para tu team.')
+        _cliente_cache = Cliente(os.environ.get('MERYN_BASE_URL', BASE_POR_DEFECTO), key)
+    return _cliente_cache
+
+
+def _anotacion(nombre, ayuda):
+    return Annotated[tipo_de(nombre), Field(description=ayuda)]
+
+
+def _fabricar(tool):
+    """Una función con la firma que el SDK necesita para generar el esquema."""
+
+    async def llamar(**argumentos):
+        try:
+            # El cliente es síncrono (urllib) y acá estamos en un loop: va a un hilo para
+            # no bloquear el servidor mientras una corrida tarda.
+            return await asyncio.to_thread(cliente().llamar, tool.nombre, argumentos)
+        except ErrorDeApi as e:
+            # El error de la API se devuelve COMO RESULTADO de la tool, no como excepción
+            # del protocolo: un 409 "ya está corriendo" o un 402 "tu plan no alcanza" son
+            # cosas que el agente tiene que poder leer y decidir qué hacer, no fallas del
+            # transporte.
+            return json.loads(json.dumps({'error': str(e), 'detail': e.cuerpo}, default=str))
+
+    llamar.__signature__ = inspect.Signature(
+        [
+            inspect.Parameter(
+                nombre,
+                inspect.Parameter.KEYWORD_ONLY,
+                annotation=_anotacion(nombre, ayuda),
+                # Los obligatorios van SIN default: así el esquema los marca `required`.
+                default=inspect.Parameter.empty if nombre in tool.obligatorios else None,
+            )
+            for nombre, ayuda in tool.argumentos.items()
+        ]
+    )
+    llamar.__annotations__ = {n: _anotacion(n, a) for n, a in tool.argumentos.items()}
+    llamar.__name__ = tool.nombre
+    return llamar
+
+
+for _tool in TOOLS:
+    servidor.add_tool(_fabricar(_tool), name=_tool.nombre, description=_tool.descripcion)
+
+
+def main():
+    """El entry point que declara `pyproject.toml` (`meryn-mcp`)."""
+    servidor.run('stdio')
+
+
+if __name__ == '__main__':
+    main()

meryn_mcp-0.1.0/pyproject.toml

@@ -0,0 +1,42 @@
+[project]
+name = "meryn-mcp"
+version = "0.1.0"
+description = "MCP server for the meryn API — read your MMM results and launch runs from Claude"
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+authors = [{ name = "meryn", email = "hi@meryn.ai" }]
+keywords = ["mcp", "mmm", "marketing-mix-modeling", "robyn", "meridian", "pymc-marketing"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Topic :: Scientific/Engineering :: Information Analysis",
+]
+# Una sola dependencia, y es el SDK del protocolo. Todo lo demás (HTTP, JSON, hashing)
+# sale de la stdlib: el que instala esto es un cliente en su máquina, y cada dependencia
+# de más es algo que puede chocar con lo que ya tenga.
+# ⚠️ Pineado al MAJOR: entre 1.x y 2.x el SDK renombró `FastMCP` a `MCPServer`, cambió
+# cómo se registran las tools y renombró `inputSchema` a `input_schema`. El código de acá
+# es 2.x, y con la 1.x el servidor no arranca.
+dependencies = ["mcp>=2.0,<3"]
+
+[project.urls]
+Homepage = "https://meryn.ai"
+Documentation = "https://meryn.ai/docs/api/mcp/"
+"API reference" = "https://meryn.ai/api/v1/docs/"
+
+[project.scripts]
+meryn-mcp = "meryn_mcp.servidor:main"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+# ⚠️ **Un PAQUETE, no dos módulos sueltos**, y el motivo aparece recién al publicar: con
+# `include = ["meryn_mcp.py", "servidor.py"]` el wheel instalaba un módulo top-level
+# llamado **`servidor`** en el `site-packages` de cualquiera — un nombre genérico que
+# puede chocar con lo que el usuario ya tenga. Adentro del repo daba igual; distribuido,
+# no. Ahora todo cuelga de `meryn_mcp/`, que es el único nombre que este paquete toma.
+[tool.hatch.build.targets.wheel]
+packages = ["meryn_mcp"]