Plug Phaide's Analysis Engine Into Any AI Agent

Your analytics engine, now an MCP server

Phaide now speaks the Model Context Protocol (MCP). The same engine that powers chat analysis inside the product — code execution paired with automated data exploration — is exposed as an MCP server that any external chatbot or agent can call.

Connect an MCP-capable host such as the MCP Inspector, a Python fastmcp client, or your own agent framework, and it can ask questions of your organization's data in natural language and receive structured answers in return. Everything runs through one Streamable HTTP endpoint, https://api.beta.phaide.ai/v1/mcp/, and authentication reuses the developer API keys you already manage inside Phaide — there is no separate credential system to set up.

The server exposes five tools. run_phaide_agent starts an analysis and immediately returns a run_id. get_phaide_agent_result polls that run until it finishes and hands back the answer as Markdown along with references to any charts or tables. render_phaide_plot and render_phaide_table turn those references into a rendered Plotly chart or table. And get_phaide_context returns your schema, accumulated memories, and uploaded files in a single call, so an agent can ground itself before it asks anything. Clients that support MCP Resources can read the same Context Layer through phaide:// URIs instead.

Under the hood, each run drives the same analysis agent that powers in-product chat, with the same code-execution and exploration abilities. So the questions an agent can ask are the questions your team already asks Phaide: ranking products by sales, breaking a metric down by segment, trending a value over time, or following a thread of follow-up questions across your connected data.

One integration, governed access, real visuals

Because Phaide implements a standard protocol, you integrate once and reach every MCP host. The agents your team already uses can query company data without a bespoke connector and without you re-exposing a database.

Access stays governed. Every key is automatically scoped to its organization, so an agent only ever sees the data that key is entitled to. Cross-tenant requests for a run or an artifact return "not found" rather than leaking anything. Keys carry an expiration — anywhere from one hour to one year, or no expiration for self-hosted setups — and any key can be revoked instantly, cutting off every application using it.

The results are not raw rows. Each run returns a written answer plus artifacts, and on a host that supports MCP Apps those artifacts render as interactive Plotly charts and formatted tables right inside the conversation. On hosts without that support, the same tools return the underlying chart and table JSON so you can render it yourself.

The design favors reliability over blocking calls. Analysis runs asynchronously: run_phaide_agent returns a run_id in an instant, and you poll for the result, so a long-running query never holds a connection open or times out. Result payloads stay lean, too — a run returns references to its charts and tables rather than inlining megabytes of data, and you fetch the full artifact only when you want to render it. The transport is stateless, which keeps connections reliable across multi-machine deployments — you never depend on a session being pinned to one process.

From API key to first answer in minutes

Getting connected takes only a few steps inside Phaide.

1. Open the account menu — your initials at the bottom-left of the sidebar — and choose Developer. This opens the developer settings, which has three tabs: API keys, MCP, and REST API.
2. On the API keys tab, click Create API key. Give the key a Label, choose an Expiration (1 hour, 1 day, 7 days, 30 days, 1 year, or No expiration), and confirm. Copy the key right away — for security it is shown only once.
3. Switch to the MCP tab. It lists the endpoint, the transport (Streamable HTTP, stateless), the authentication header, the available tools, and copy-ready client snippets for Python, the MCP Inspector, and config-file setups.
4. Point your MCP client at https://api.beta.phaide.ai/v1/mcp/ and send your key as Authorization: Bearer ph-v1-…. To confirm a key is valid first, call the REST identity endpoint — a 200 response means the key is active in that environment.
5. From your agent, call run_phaide_agent with a prompt, poll get_phaide_agent_result until it reports a terminal status, then pass each artifact_id to render_phaide_plot or render_phaide_table to display the visuals.

That is the full loop: a question goes in, an answer with charts and tables comes back, all scoped to the organization behind the key.

Your data, wherever your agents already work

Your analytics shouldn't be trapped behind a single screen. With the MCP API, the questions your team would normally type into Phaide can now be answered by the AI agents they already work in every day — governed, organization-scoped, and visual. Issue a key, paste in the endpoint, and let your agents start asking.

FAQ

Do I need anything besides a developer API key? No. The MCP endpoint authenticates with the same ph-v1-… developer API keys as the REST API. Create one on the API keys tab and send it as a Bearer token.

Where do I create and manage keys? In Phaide, open the account menu (your initials, bottom-left of the sidebar) → Developer → API keys. There you can create keys, see each key's label, masked value, status, and last-used time, and revoke any key.

Which MCP clients are supported? Any client that speaks Streamable HTTP and can send an Authorization header — for example the MCP Inspector, a Python fastmcp client, or config-file launchers like mcp-remote. The MCP tab in Phaide includes ready-to-use snippets.

Why isn't my chart rendering? Visual rendering happens only on hosts that support MCP Apps. On other clients, render_phaide_plot and render_phaide_table return the chart or table data as JSON, plus a note that the host doesn't support rendering — you can draw it yourself from that data.

Is my data isolated from other organizations? Yes. Every key is scoped to its organization, and any run or artifact belonging to another organization returns "not found." Masking is removed before results are returned to you.

What happens when a key expires or is revoked? The key stops authenticating immediately, and any application using it loses access at once. Revocation cannot be undone, so issue a fresh key to restore access.

Can I do the same thing over plain REST instead of MCP? Yes. The REST API tab documents /v1 endpoints — ingest, agent runs, artifacts, and context — that share the same engine and the same API keys, for clients that don't use MCP.