Mammoth Analytics

io.mammothPublished by mammoth.ioOfficial publisherv0.2.12Updated Nov 4, 2026

Explore, clean, transform and export your Mammoth Analytics data from an AI client.

The publisher's own server: Mammoth Docs

VerifiedStreamable HTTPWeb executableFiles & StorageData & Analytics

Overview

AI-generated overview

Mammoth Analytics MCP server that lets an AI client explore, clean, transform and export your Mammoth data as the signed-in user.

What you can do
  • Explore and read Mammoth data through read tools that shape API answers for the model
  • Clean and transform data by mapping transformations to pipeline tasks and waiting on the jobs they start
  • Work with views, pipelines, files and dashboards through the server's tool modules
  • Export data and hand the user links back to the Mammoth web app
  • Upload a local file through a short-lived upload page so it can be used in Mammoth
When to use it
Use it when your data lives in Mammoth Analytics and you want an AI client such as Claude or ChatGPT to inspect, clean, reshape or export it without leaving the chat. It suits analysts and teams already working inside a Mammoth workspace and project.
Requirements
Either the hosted endpoint at mcp.mammoth.io, added to your MCP client with no install, or a local install of the mammoth-mcp-server Python package. Both need a Mammoth account and OAuth sign-in with a workspace and project chosen. A local deployment also needs MCP_ENCRYPTION_KEY (a Fernet key) and a Redis instance via MCP_REDIS_URL, plus Mammoth-side OAuth configuration.
Before you install
Sign-in is OAuth and every tool call runs with your Mammoth permissions, so the assistant can change data in your workspace, not just read it. A token is bound to one workspace and calls for another are refused. Upload links keep your sealed token in Redis until the upload happens or 30 minutes pass. A local deployment must set MCP_ENCRYPTION_KEY, the only secret it keeps, and will not start without it.

Installation

In SourceWeft

  1. Open Mammoth Analytics in the dashboard and add it to a workspace.
  2. Connect the required credentials. They are stored privately and never shown on public pages.
  3. Enable the server for the chats that should use its tools.

Web executable via Streamable HTTP. Remote servers run from the web runtime once configured in a workspace.

Use with an agent

Paste this prompt into Claude Code, Codex, Cursor or another agent — or into SourceWeft chat. The agent reads this server's install guide, shows you its publisher, endpoint and sign-in, and adds it to your client once you agree. Keys never go into a command.

Read https://sourceweft.com/mcp/io.mammoth%2Fmcp/install.md and connect the MCP server it describes to my client. Before changing any config, show me its publisher, endpoint and sign-in method and wait for my OK. Never put an API key in a command or in a file I would commit; ask me where it should come from.

Read the install guide the agent follows

Other MCP clients

Add this to your client's mcpServers config. The client completes OAuth sign-in on first connect.

{
  "mcpServers": {
    "mammoth-analytics": {
      "type": "http",
      "url": "https://mcp.mammoth.io/mcp"
    }
  }
}

README

mammoth-mcp-server

The Mammoth MCP server. An AI client (Claude, ChatGPT) uses its tools to explore, clean, transform and export data in Mammoth, as the signed-in user.

The server depends on one Mammoth package: the SDK (mammoth-io). Every tool reaches Mammoth through the API, as the SDK does. The server imports no backend code.

Hosted or local

  • Hosted: Mammoth runs this server at https://mcp.mammoth.io/mcp. Add that URL to your MCP client and sign in with your Mammoth account (OAuth). Nothing to install.
  • Local: pip install mammoth-mcp-server, then set MCP_ENCRYPTION_KEY and start mammoth-mcp-server (see From a virtual environment below). MCP_ENCRYPTION_KEY must be a Fernet key: 32 url-safe base64-encoded bytes. Generate one with python -c "from cryptography.fernet import Fernet; print(Fernet.generate_key().decode())". The server refuses to start without it, or with a value that is not a Fernet key.

Layout

PathWhat it holds
mammoth_mcp_server/tools/The tools, one module per area (views, pipeline, files, dashboards, ...).
mammoth_mcp_server/sdk.pyThe SDK client a tool call is given, and the API's errors in words a model can use.
mammoth_mcp_server/jobs.pyThe wait for a job that an API route started.
mammoth_mcp_server/task_params.pyThe map from a transformation to the pipeline task the API takes.
mammoth_mcp_server/tokens.pyThe check of a caller's token: Mammoth says whether it is live and which server it is for.
mammoth_mcp_server/store.pyShort-lived records in Redis: upload tickets.
mammoth_mcp_server/upload_routes.pyThe page a user drops a local file on.
mammoth_mcp_server/server_card.pyThe public server card at /.well-known/mcp/server-card.json.
mammoth_mcp_server/shape.pyWhat a read tool hands the model, cut from the API's answer.
mammoth_mcp_server/app.pyThe ASGI app and main().
mammoth_mcp_server/config.pyEvery deployment setting, read from the environment.

Settings

VariableDefaultMeaning
MCP_SERVER_URLhttps://mcp.mammoth.ioThis server, as a client reaches it.
MAMMOTH_APP_URLhttps://app.mammoth.ioThe web app, for the links a tool gives the user.
MAMMOTH_DASHBOARD_URLMAMMOTH_APP_URLThe host that serves a published dashboard.
MAMMOTH_API_URLMAMMOTH_APP_URL + /api/v2The API every tool call goes to.
MAMMOTH_API_ROOT/api/v2The path the API is served under. Set it empty for an API reached directly.
MAMMOTH_OAUTH_URLMAMMOTH_APP_URL + /api/v2Mammoth's authorization server (its issuer), where a client signs the user in.
MCP_REDIS_URLredis://localhost:6379/0Where upload tickets are kept.
MCP_ENCRYPTION_KEYnoneA Fernet key. The caller's token in an upload ticket is sealed with it. Required.
MCP_STORE_PREFIXmammoth_mcpKeeps this deployment's records apart in a shared Redis.
MCP_HOST, MCP_PORT127.0.0.1, 8270Where the server listens.

Sign-in

This server signs nobody in. Mammoth's own authorization server does: the OAuth server the Mammoth API serves. This server is an OAuth resource server only.

  1. A client calls /mcp with no token. The server answers 401 and points to /.well-known/oauth-protected-resource/mcp.
  2. That document names Mammoth's authorization server (MAMMOTH_OAUTH_URL). The client reads the server's metadata there and sends the user to it.
  3. The user signs in to Mammoth, picks a workspace and a project, and approves. The client asks for a token for this server's URI, <MCP_SERVER_URL>/mcp (the resource parameter, RFC 8707).
  4. The client calls /mcp with that token. On every request the server asks Mammoth what the token is for (GET /workspaces/current). The server takes the token only when Mammoth says it is live and was issued for this server's URI.
  5. Each tool call goes to the Mammoth API with the same token, so the user's permissions apply.

A token belongs to one workspace. A tool call for another workspace is refused. A Mammoth API token made by hand in Workspace settings was issued for no server, so this server refuses it.

The server keeps no sign-in and no token, with one exception: an upload link holds the caller's token, sealed, in Redis until the user uploads or 30 minutes pass.

What Mammoth needs

  • The MCP server's URI, <MCP_SERVER_URL>/mcp, in mvc-service const.ini, section [oauth], key MCP_RESOURCES. Mammoth issues a token for no other resource.
  • GET /workspaces/current must return the token's resource beside the workspace id. Without it this server refuses every token.

Before it works in an environment below lists every step, in the order to check them.

Run

As a container, which needs nothing on the host but Docker

The image is built from this repository, so a deployment never waits for a release of the SDK. Build it from the repository root, which is the build context:

bash
cp mammoth-mcp-server/deploy/.dockerignore.example .dockerignoredocker build -f mammoth-mcp-server/deploy/Dockerfile -t mammoth-mcp-server .docker run --env-file mammoth-mcp-server/deploy/.env -p 8270:8270 mammoth-mcp-server

With a Redis of its own, as one stack:

bash
cp mammoth-mcp-server/.env.example mammoth-mcp-server/deploy/.env   # then set the valuesdocker compose -f mammoth-mcp-server/deploy/compose.yaml up -d --build

The server keeps nothing in memory between requests, so it scales by adding containers. They share only Redis.

From a virtual environment

bash
pip install mammoth-mcp-servercp .env.example .env        # then set the valuesmammoth-mcp-server          # or: uvicorn mammoth_mcp_server.app:create_app --factory

What deploy/ holds

FileWhat it is for
DockerfileThe image, built from this repository
compose.yamlThe server and a Redis, as one stack
.dockerignore.exampleCopy to the repository root before building
mammoth-mcp-server-container.service.examplesystemd, running the container
mammoth-mcp-server.service.examplesystemd, running a virtual environment
nginx.example.confBoth server blocks a deployment needs

Before it works in an environment

Each of these stops the sign-in on its own, so check them in order.

  1. DNS and the front door point MCP_SERVER_URL at the server's port. deploy/nginx.example.conf holds the server block.

  2. MCP_ENCRYPTION_KEY is set. It is the only secret this server keeps. Nothing else is required that has no default; see Settings.

  3. Mammoth knows this server: MCP_RESOURCES = <MCP_SERVER_URL>/mcp, in mvc-service const.ini, section [oauth]. Mammoth issues a token for no other resource.

  4. The Mammoth host serves its OAuth metadata where a client looks for it. For an issuer with a path, RFC 8414 puts the document at /.well-known/oauth-authorization-server/api/v2, and apiv2 serves it at its own path, so the front door has to join the two. The second server block in deploy/nginx.example.conf does it. Check it with:

    bash
    curl https://<mammoth host>/.well-known/oauth-authorization-server/api/v2

    It must answer the document, not 404.

  5. The web app's OAuth consent page is deployed. Without it the user lands on a page that does not exist, and approves nothing.

Then a client connects to <MCP_SERVER_URL>/mcp, and the user signs in to Mammoth and picks a workspace and a project.

Tests

bash
cd mammoth-mcp-serverpython -m pytest tests -q

The tests reach no server. The SDK client and the tools are real; only the HTTP transport under the client is replaced.

Source: mammoth-mcp-server/README.md at commit 4e7b528

Tools

0
This server asks you to sign in, so SourceWeft could not read its tools without an account and has not indexed them. What a connected account sees can depend on that account and its permissions.

Version history

6
  1. v0.2.12LatestNov 4, 2026
  2. v0.2.11Nov 4, 2026
  3. v0.2.9Nov 3, 2026
  4. v0.2.7Oct 21, 2026
  5. v0.2.1Oct 13, 2026
  6. v0.1.1Oct 12, 2026

Score

75% of the applicable checks met

How complete this listing is, computed from the registry entry, the endpoint and public sources. Not a rating of the server and not a statement that it is safe or working today: reachability is a dated check, and no installs or reviews go into the score.

  • Reached in the last 30 daysRequired25 pts
  • Auth declaredRequired10 pts
  • Tools listed15 pts

    Answer tools/list without a credential, or ship a package that starts in a sandbox without one.

  • DescriptionRequired15 pts
  • Logo10 pts
  • Documentation15 pts
  • License10 pts

    Declare a license in the repository or the registry entry.

Other Mammoth integrations

Mammoth Docs

io.mammothOfficial publisher

Mammoth Docs's hosted MCP server, published by mammoth.io; no sign-in required; Streamable HTTP; 3 tools.

Streamable HTTPWeb executable
Knowledge & Memory3 toolsNov 3, 2026