Skip to main content
Glama
Subindex MCP Server
by EliyahuAI

Subindex

Verified Research Engine · subindex.ai · Launch App

Subindex generates, validates, and updates research tables by synthesizing hundreds of calls to Perplexity and Claude. Give it a prompt or an existing table and it returns structured, verified answers across an entire research domain — not just a single query, but a complete field of questions answered at once.

What you want to do

How

Live example

Gather everything — survey a complete research domain at once

Prompt → structured verified table

50+ Phase 3 oncology trials

Monitor anything — news, analyst projections, time-sensitive data

Upload or generate → keep current

Market info for 10 stocks

See everywhere — run the same questions across many entities

One table, many subjects

GenAI adoption across Fortune 500

How to Access

You want to…

Use

Try it out or iron out your use case

subindex.ai/app — web GUI for table validation and generation

Fact-check text or documents interactively

subindex.ai/chex — web GUI for reference checks

Let an AI agent drive a workflow autonomously

MCP server — install once, describe your task in plain English

One-off automation without writing code

MCP server via Claude Code, Claude Desktop, or any MCP-compatible client

Run repeatable pipelines or batch jobs

REST API + example scripts

Integrate into a product or SaaS

REST API directly

GUI → API: The web GUIs are ideal for exploring and refining your use case. Once you know what you want, the MCP server or REST API is the better path — faster, repeatable, and fully automatable.


Related MCP server: GPT Researcher MCP Server

Table of Contents


Get Your API Key

Get your API key at subindex.ai/account. New accounts receive $20 in free credits.


Download Examples

All scripts require Python 3.10+ and pip install requests.

Script

Description

Download

subindex_client.py

Shared REST client (required by all examples)

download

01_validate_table.py

Validate an existing table

download

02_generate_table.py

Generate a table from a prompt

download

03_update_table.py

Re-run validation on a completed job

download

04_reference_check.py

Fact-check text or documents

download

Or clone the full example set:

# Download all examples at once
curl -O https://subindex-storage.s3.amazonaws.com/website_downloads/examples/subindex_client.py \
     -O https://subindex-storage.s3.amazonaws.com/website_downloads/examples/01_validate_table.py \
     -O https://subindex-storage.s3.amazonaws.com/website_downloads/examples/02_generate_table.py \
     -O https://subindex-storage.s3.amazonaws.com/website_downloads/examples/03_update_table.py \
     -O https://subindex-storage.s3.amazonaws.com/website_downloads/examples/04_reference_check.py
pip install requests
export SUBINDEX_API_KEY=sbx_live_...

Quick Start: MCP

The MCP server lets any AI agent drive the full Subindex workflow autonomously — no scripting required.

Connects directly to the hosted Subindex server over HTTP. No local install, no uvx, no package management — just one command.

Claude Code:

claude mcp add subindex \
  --transport http \
  https://mcp-server-subindex-production.up.railway.app/ \
  --header "X-Api-Key: sbx_live_your_key_here"

Via config file (.mcp.json in your repo root, or claude_desktop_config.json):

{
  "mcpServers": {
    "subindex": {
      "type": "http",
      "url": "https://mcp-server-subindex-production.up.railway.app/",
      "headers": {
        "X-Api-Key": "sbx_live_your_key_here"
      }
    }
  }
}

Why HTTP over uvx? The HTTP connection runs on Railway — always up to date, no local Python environment needed, and no version drift between the package you installed and the live server. Recommended for Claude Code and any project-level config.

Option B — Local install via uvx

Runs the server locally on your machine using uvx. Useful for Claude Desktop or offline/air-gapped environments.

Claude Code:

claude mcp add subindex uvx mcp-server-subindex \
  -e SUBINDEX_API_KEY=sbx_live_your_key_here

Claude Desktop — add to claude_desktop_config.json:

  • macOS: ~/Library/Application Support/Claude/claude_desktop_config.json

  • Windows: %APPDATA%\Claude\claude_desktop_config.json

{
  "mcpServers": {
    "subindex": {
      "command": "uvx",
      "args": ["mcp-server-subindex"],
      "env": {
        "SUBINDEX_API_KEY": "sbx_live_your_key_here"
      }
    }
  }
}

Project config (shared repo) — add .mcp.json to your repo root. Each person uses their own key; no key is committed to the repo:

{
  "mcpServers": {
    "subindex": {
      "command": "uvx",
      "args": ["mcp-server-subindex"],
      "env": {
        "SUBINDEX_API_KEY": "${SUBINDEX_API_KEY}"
      }
    }
  }
}

OpenAI Codex CLI — add to your Codex config file (~/.codex/config.toml on macOS/Linux, %USERPROFILE%\.codex\config.toml on Windows):

[mcp_servers.subindex]
command = "uvx"
args = ["mcp-server-subindex"]

[mcp_servers.subindex.env]
SUBINDEX_API_KEY = "sbx_live_your_key_here"

Then restart Codex and verify:

codex mcp list

Option C — Smithery

Smithery is an MCP registry that works with Claude Code and other MCP-compatible clients including OpenClaw.

Step 1 — Install and log in:

npx -y @smithery/cli@latest login
npx -y @smithery/cli@latest mcp add subindex/subindex --client claude-code

Step 2 — Authenticate with your API key:

Open your MCP client (e.g. Claude Code), go to /mcp, click subindex → Authenticate, and enter your Subindex API key in the Smithery page that opens.

Smithery login is a one-time step. You must log in before adding servers, or authentication will not be set up correctly.


What to Ask Your Agent

Once the MCP server is installed, describe your task in plain English. The agent drives the full workflow, pausing only when your input is genuinely needed.

Validate a table:

"Validate companies.xlsx using Subindex. Interview me about what each column means, then run the preview. If the results look good, approve the full validation."

Generate a table:

"Use Subindex to generate a table of the top 20 US hedge funds with columns: fund name, AUM, primary strategy, founding year, and HQ city. Approve the full validation when the preview looks right."

Re-run validation on the same table:

"Re-run update_table on job session_20260217_103045_abc123 to get an updated validation pass."

Fact-check a document:

"Use Subindex to fact-check this analyst report." (paste the text or share the file path)


Workflows

1. Validate an Existing Table

Minimum rows: Subindex is designed for tables with 4 or more data rows. Fewer rows may produce low-quality results.

Full flow: upload → interview → preview → refine → approve → download

upload_file(filename, file_type, file_size [, file_path])   ← omit file_path on HTTP/Railway transport; run returned curl_command instead
  → start_table_validation(session_id, s3_key, filename)
      ┌── match found (score ≥ 0.85) → [preview auto-queued; response has preview_queued=true + job_id]
      └── no match → interview auto-started
            → wait_for_conversation / poll get_conversation
              → send_conversation_reply  (if AI asks questions)
              → [interview complete → preview auto-queued]

  → wait_for_job(job_id or session_id)  ← blocks until preview_complete
      → [optional] refine_config(conv_id, session_id, instructions)
      → approve_validation(job_id, cost_usd)
      → wait_for_job(job_id)            ← blocks until completed
      → get_results(job_id)

Key behavior: The preview is always auto-queued — after the interview finishes (trigger_config_generation=true), or when a config match is found (match_score ≥ 0.85, response includes preview_queued: true and job_id). Call wait_for_job(session_id) directly in all cases (see Config reuse).

Upload interview auto-approval: The interview may auto-approve in a single turn. If the conversation response has user_reply_needed: false and status: approved, proceed to wait_for_job(session_id) immediately — no reply is needed, even if the AI's message appears to ask for confirmation.

Skip the interview with instructions (fire-and-forget config generation):

Pass instructions to start_table_validation to bypass the interactive interview. The AI reads the table structure + your instructions and generates a config directly, then auto-triggers the preview — no clarifying questions needed.

start_table_validation(session_id, s3_key, filename,
  instructions="This table lists hedge funds. Validate AUM, strategy, and HQ city. Use Bloomberg and SEC filings.")
  → response includes instructions_mode=true
  → wait_for_job(session_id)          ← config generation + preview tracked automatically
  → approve_validation(job_id, cost_usd)
  → wait_for_job(job_id)
  → get_results(job_id)

Cost gate: Config generation and the 3-row preview are free. Full validation is charged at approve_validation — you always see the cost estimate at preview_complete before anything is billed. If your balance is insufficient, approve_validation returns an insufficient_balance error with the required amount.

Refine the config before approving by calling refine_config. This adjusts how columns are validated (sources, strictness, interpretation) — it cannot add or remove columns:

refine_config(conversation_id, session_id,
  "Use SEC filings as the primary source for revenue. Require exact match for ticker symbols.")

A new preview runs automatically after refinement.

Python script: examples/01_validate_table.py

export SUBINDEX_API_KEY=sbx_live_...
python examples/01_validate_table.py companies.xlsx
python examples/01_validate_table.py companies.xlsx --refine "Add LinkedIn URL column"

 Fire-and-forget: provide instructions to skip the interview entirely
python examples/01_validate_table.py companies.xlsx \
    --instructions "This table lists hedge funds. Validate AUM, strategy, and HQ city."

Which mode to use: Always try file_path first. If the server can read the file (stdio/uvx transport), upload completes in one step. If you get "File not found" (HTTP/Railway transport — server is remote), call again without file_path to receive a presigned S3 URL and a ready-to-run curl_command. The two-step path requires shell access to run curl; Claude Desktop users should use the uvx transport so file_path works.


2. Generate a Table from a Prompt

Describe the table you want — rows, columns, scope — and Subindex builds and validates it from scratch. Designed for tables with 4 or more rows.

start_table_maker("Top 20 US biotech companies: name, ticker, market cap, lead drug, phase")
  → wait_for_conversation / poll get_conversation
    → send_conversation_reply  (if AI asks clarifying questions)
    → [table builds → preview auto-queued]

  → wait_for_job(session_id)          ← spans table-maker + preview phases
    → approve_validation(job_id, cost_usd)
    → wait_for_job(job_id)
    → get_results(job_id)

Auto-approve: The agent can auto-approve the preview and proceed to full validation without human intervention. The preview table is included inline in the preview_complete response.

Cost: ~$0.05/cell (standard), up to ~$0.25/cell (advanced). $2 minimum per run.

Skip confirmation with auto_start=True (fire-and-forget generation):

Pass auto_start=True to skip the AI's clarifying questions and structure-confirmation step. The AI generates the table immediately from the message alone. Use when your message fully describes the desired table.

start_table_maker(
  "Top 20 US hedge funds: fund name, AUM, primary strategy, founding year, HQ city",
  auto_start=True)
  → wait_for_conversation(conversation_id, session_id)
      ← returns trigger_execution=true on first response (no Q&A)
  → wait_for_job(session_id)          ← table building + preview
  → approve_validation(job_id, cost_usd)
  → wait_for_job(job_id)
  → get_results(job_id)

Why wait_for_conversation with auto_start=True? Even though there is no Q&A, wait_for_conversation is still required — it returns trigger_execution: true in a single blocking call (no reply needed), signaling that the table-maker has started. Calling wait_for_job before this call returns would be premature, as the table-maker may not have been triggered yet.

Cost gate: Table building and the 3-row preview are free. Full validation is charged at approve_validation — you always see the cost estimate at preview_complete before anything is billed. If your balance is insufficient, approve_validation returns an insufficient_balance error with the required amount.

Python script: examples/02_generate_table.py

python examples/02_generate_table.py "Top 10 US hedge funds: fund name, AUM, strategy, HQ city"
python examples/02_generate_table.py --prompt-file my_spec.txt

 Fire-and-forget: skip clarifying Q&A and generate immediately from the prompt
python examples/02_generate_table.py --auto-start "Top 10 US hedge funds: fund name, AUM, strategy, HQ city"

3. Update a Table (Re-run Validation Pass)

Re-run validation on a completed job — no re-upload or manual edits needed. The table iterates automatically, re-validating the same data with the same config to pick up any changes in source data.

If you want to incorporate manual edits to the output file, re-upload the edited file via upload_file + start_table_validation — a matching config will be found automatically (score ≥ 0.85).

update_table(source_job_id)           ← re-validates existing enriched output
  → wait_for_job(new_job_id)          ← blocks until preview_complete
    → approve_validation(new_job_id, cost_usd)
    → wait_for_job(new_job_id)
    → get_results(new_job_id)

Python script: examples/03_update_table.py

python examples/03_update_table.py session_20260217_103045_abc123
python examples/03_update_table.py session_20260217_103045_abc123 --version 2

4. Fact-Check Text or Documents (Chex)

Submit any text, report, or document. Subindex checks each factual claim against authoritative sources and returns the same output format as standard table validation: an Excel (XLSX) file, an interactive viewer URL, and a metadata JSON.

Minimum claims: Subindex is designed for text with 4 or more factual claims. Fewer claims may produce low-quality results.

start_reference_check(text="...")           ← inline text (or auto_approve=True to skip the gate)
  or
upload_file(filename, "pdf", file_size [, file_path])   ← upload PDF/document first
  → start_reference_check(s3_key=s3_key)

→ wait_for_job(job_id)                ← spans extraction + 3-row preview; stops at preview_complete
  → preview_table (3 validated sample claims) + cost_estimate shown in response
  → approve_validation(job_id, approved_cost_usd=X)   ← triggers Phase 2
  → wait_for_job(job_id)              ← waits for completed
  → get_results(job_id)               ← download_url (XLSX) + interactive_viewer_url + metadata_url

Three-phase flow: Phase 1 (claim extraction, free) runs automatically, then a 3-row preview validates sample claims (free, auto-triggered). Both phases are tracked by a single wait_for_job call that stops at status=preview_complete. Review preview_table (3 validated sample claims with support level and citations) and cost_estimate, then call approve_validation to start Phase 2 (full validation, charged). Pass auto_approve=True to skip the gate and run straight through to completed.

Progress tracking: get_job_messages returns empty during claim extraction (Phase 1). Progress messages are available during the preview validation phase. wait_for_job handles both phases automatically.

Output: Excel (XLSX) file with per-claim rows. Support levels: SUPPORTED / PARTIAL / UNSUPPORTED / UNVERIFIABLE. Share interactive_viewer_url with human stakeholders — it renders sources and confidence scores in a clean UI.

Python script: examples/04_reference_check.py | Sample output: sample_outputs/reference_check_output.json

# Fact-check inline text
python examples/04_reference_check.py --text "Bitcoin was created by Satoshi Nakamoto in 2009."

# Fact-check a PDF
python examples/04_reference_check.py --file analyst_report.pdf

# Fact-check multiple documents concatenated
cat doc1.txt doc2.txt | python examples/04_reference_check.py --stdin

--stdin: Concatenates all piped content as a single inline text payload. All claims are attributed to the combined document.


Environment Variables

Variable

Description

SUBINDEX_API_KEY

API key from subindex.ai/account. Required. New accounts get $20 free.

SUBINDEX_API_URL

Override the API base URL (useful for dev/staging environments).


Direct REST API

All tools in the MCP server are thin wrappers over the REST API. You can call it directly from any language.

Base URL: https://api.subindex.ai/v1

Auth: Authorization: Bearer sbx_live_your_key_here

Response envelope:

{
  "success": true,
  "data": { ... },
  "meta": { "request_id": "...", "timestamp": "..." }
}

Python client (minimal)

import os, requests

BASE_URL = "https://api.subindex.ai/v1"
HEADERS  = {"Authorization": f"Bearer {os.environ['SUBINDEX_API_KEY']}"}

def api_get(path, **kwargs):
    r = requests.get(f"{BASE_URL}{path}", headers=HEADERS, **kwargs)
    r.raise_for_status()
    return r.json()["data"]

def api_post(path, **kwargs):
    r = requests.post(f"{BASE_URL}{path}", headers=HEADERS, **kwargs)
    r.raise_for_status()
    return r.json()["data"]

A full standalone client module is in examples/subindex_client.py.


API Endpoint Reference

Uploads

Method

Path

Description

POST

/uploads/presigned

Get a presigned S3 URL to upload a file

PUT

<presigned_url>

Upload file bytes directly to S3 (no auth header)

POST

/uploads/confirm

Confirm upload; detect config matches; auto-start interview if no match

Presigned upload request:

{
  "filename": "companies.xlsx",
  "file_size": 2048000,
  "file_type": "excel",
  "content_type": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
}

Content types: excel → .xlsx, csv → .csv, pdf → .pdf

Confirm upload request (optional fields):

{
  "session_id": "session_20260305_...",
  "s3_key": "results/.../file.xlsx",
  "filename": "companies.xlsx",
  "instructions": "Validate AUM, strategy, and HQ city. Use Bloomberg and SEC filings as sources.",
  "config_id": "session_20260217_103045_abc123_config_v1_..."
}

instructions — if provided, bypasses the interactive upload interview. The AI generates the config directly from the table structure + instructions. Response includes instructions_mode: true and conversation_id. Use wait_for_job(session_id) to track progress — do NOT poll the conversation.

config_id — if provided, skips matching and the interview entirely. The specified config is applied immediately and the preview is auto-queued. Response includes preview_queued: true and job_id. Use wait_for_job(job_id) to track progress. The configuration_id for any completed job is returned by GET /jobs/{id}/results under job_info.configuration_id.


Conversations

Method

Path

Description

POST

/conversations/table-maker

Start a Table Maker session with a natural language prompt

GET

/conversations/{id}?session_id=

Poll conversation for status / AI messages

POST

/conversations/{id}/message

Send a reply to the AI

POST

/conversations/{id}/refine-config

Refine the config with natural language instructions

Table Maker request body:

{
  "message": "Top 20 US hedge funds: fund name, AUM, primary strategy, founding year, HQ city",
  "auto_start": true
}

auto_start — if true, the AI skips clarifying questions and the structure-confirmation step, proceeding directly to table generation. The first get_conversation response will have trigger_execution: true. Use when your message fully describes the desired table.


Jobs

Method

Path

Description

GET

/jobs/{id}

Get job status and progress

GET

/jobs/{id}/messages

Fetch live progress messages (paginated by since_seq)

POST

/jobs/{id}/validate

Approve full validation — credits charged here

GET

/jobs/{id}/results

Fetch download URL, metadata, viewer URL

POST

/jobs/update-table

Re-validate enriched output after corrections

POST

/jobs/reference-check

Submit text or file for claim verification

Job status values:

Status

Meaning

queued

Accepted, waiting to start

processing

Actively running

preview_complete

Free preview done — review results and approve full run

completed

Full validation complete, results ready

failed

Error — check error.message


Account

Method

Path

Description

GET

/account/balance

Current credit balance and this-month usage

GET

/account/usage

Billing history (supports start_date, end_date, limit, offset)


MCP Prompts

Three built-in prompts act as workflow starters — select them from the prompt picker in your MCP client (Claude Code: / menu; Claude Desktop: the prompt icon) and fill in the arguments.

Prompt

Arguments

What it does

generate_table

description (required), columns (optional)

Builds a step-by-step instruction for creating a new research table from a natural language description

validate_file

file_path (required), instructions (optional)

Generates the full validation workflow for an existing Excel or CSV file

fact_check_text

text (required)

Generates the reference-check workflow for fact-checking a text passage


MCP Tool Reference

Every tool response includes a _guidance block with a plain-English summary and the exact next tool call(s) — enabling fully autonomous agent workflows.

Tool

Description

upload_file

Upload Excel, CSV, or PDF. Try with file_path first (one step, stdio/uvx). If the server can't read the local path, call again without file_path to get a presigned S3 URL + curl command (HTTP/Railway transport — requires shell to run curl).

start_table_validation

Confirm upload; detect config matches; auto-start interview if needed

start_table_maker

Start an AI conversation to generate a table from a prompt

get_conversation

Poll a conversation for AI responses or status changes

send_conversation_reply

Reply to AI questions during an interview or table-maker session

wait_for_conversation

Block until conversation needs input or finishes (emits live progress)

refine_config

Refine the validation config with natural language instructions (adjusts sources, strictness, interpretation — cannot add or remove columns)

wait_for_job

Block until preview_complete, completed, or failed (preferred progress tracker)

get_job_status

One-shot status poll

get_job_messages

Fetch progress messages with native percentages (paginated)

approve_validation

Approve preview → start full validation (credits charged here)

get_results

Download URL, inline metadata, interactive viewer URL

update_table

Re-validate enriched output after analyst corrections

start_reference_check

Submit text or file for claim and citation verification

get_balance

Check credit balance

get_usage

Review billing history


Key Behaviors

Auto-queued preview

The preview is automatically queued in all three paths after start_table_validation:

Path

Trigger

What to call next

Config match (score ≥ 0.85)

preview_queued: true in response

wait_for_job(job_id)

instructions= provided

instructions_mode: true in response

wait_for_job(session_id)

Interview ran

trigger_config_generation=true from conversation

wait_for_job(session_id)

To reuse a config from a different session, pass config_id to start_table_validation — the preview will be auto-queued immediately.

Config reuse

If start_table_validation returns match_score ≥ 0.85, the preview is automatically queued using the matched config. The response includes preview_queued: true and job_id — call wait_for_job(job_id) directly, no interview needed.

The configuration_id from any completed job's get_results response can be reused on future uploads of similar tables.

Cost confirmation gate

approve_validation requires approved_cost_usd matching the preview estimate. This prevents surprise charges. The estimate is in the preview_complete job status response under cost_estimate.estimated_total_cost_usd.

This gate applies regardless of whether instructions or auto_start was used — both only skip the interview/confirmation conversation, not the cost approval step. If your balance is insufficient when approve_validation is called, the API returns:

{ "error": "insufficient_balance", "required_usd": 4.20, "current_balance_usd": 1.50 }

Fire-and-forget shortcuts

Two optional flags let fully automated pipelines skip interactive steps:

Flag

Tool

Skips

Next step

instructions="..."

start_table_validation

Upload interview Q&A

wait_for_job(session_id)

auto_start=True

start_table_maker

Structure confirmation

wait_for_conversation → wait_for_job

These flags use different terminal signals: instructions= (a config-gen flow) causes trigger_config_generation: true on the conversation response; auto_start=True (a table-maker flow) causes trigger_execution: true. Both skip interactive Q&A but produce different fields — do not wait for trigger_execution when using the instructions= upload path. The preview_complete cost gate and approve_validation still apply.

Consuming results: humans vs AI agents

Output files generated per run:

File

Format

Description

Preview table

Markdown (inline)

First 3 rows as markdown text; returned inline in the preview_complete job status response (not a separate download). Also available in metadata.json under markdown_table.

Enriched results

Excel (.xlsx)

Ideal for sharing with humans; sources and citations are embedded in cell comments

Full metadata

metadata.json

Complete per-cell detail for every row; use the row_key field to drill into specific rows programmatically

get_results returns:

Field

Type

Best for

results.interactive_viewer_url

URL

Humans — web viewer with confidence indicators (requires login at subindex.ai with the same email as your API key)

results.download_url

Presigned URL

Humans — download the enriched Excel (.xlsx) directly

results.metadata_url

Presigned URL

AI agents — JSON file with all rows, per-cell details, and source citations

Recommended AI agent workflow:

  1. At preview_complete: read the inline preview_table (markdown, 3 rows) from GET /jobs/{id} to survey the table structure and spot-check values. The AI agent can review this inline table and call approve_validation directly — no human approval step is required.

  2. After full validation: fetch results.metadata_url → table_metadata.json. This contains every validated row.

  3. Use rows[].row_key (stable SHA-256) to cross-reference rows between the markdown summary and the detailed JSON.

  4. Per-cell fields in table_metadata.json:

    • cells[col].value — validated value (legacy files may use full_value)

    • cells[col].confidence — HIGH / MEDIUM / LOW / ID

    • cells[col].comment.validator_explanation — reasoning

    • cells[col].comment.key_citation — top authoritative source

    • cells[col].comment.sources[] — all sources with url and snippet


Pricing

Mode

Cost

Preview (first 3 rows)

Free

Standard validation

~$0.05 / cell

Advanced validation

up to ~$0.25 / cell

Minimum per run

$2.00

Reference check

TBD — contact support

Credits are prepaid. Get $20 free at subindex.ai/account.

Standard validation is used for most tables. Advanced validation is selected automatically when the table requires more sophisticated reasoning (e.g., scientific data, complex financial metrics, or cells with high ambiguity).


Available Tools

25 tools
add_pending_rowA

Add a new entity as a pending row to be included in the full validation run.

The source Excel is NOT modified — the row is stored in session state and injected in-memory at validation time. Fully reversible before approving the full run.

The full-run cost quote updates to include the new row count.

Inputs: session_id (required), entity_id (required), entity_name (required), extra_fields. Returns: result

add_validated_rowsA

Add new rows to a completed validation table.

Deduplication runs against existing rows. If confirmed=False, returns a cost quote (N_new_rows x per_row_rate from last run). If confirmed=True, appends rows to source Excel, runs validation on new rows only, and merges results into the output Excel.

Only available after full validation completes (status=completed).

Inputs: session_id (required), entities (required), confirmed. Returns: result

approve_validationA

Approve a preview and start full validation processing.

job_id: the session_id value — "job_id" and "session_id" are the same string.

approved_cost_usd MUST be provided and must match the estimated cost from the preview_complete response. This prevents accidental billing without first reviewing preview results and the cost estimate.

Workflow:

  1. Call wait_for_job to reach preview_complete — read the inline preview_table (3-row sample) and cost_estimate.estimated_total_cost_usd from the response

  2. Call approve_validation(job_id=<session_id>, approved_cost_usd=)

Inputs: job_id (required), approved_cost_usd. Returns: result

discover_rowsA

Discover and add new rows to an existing validated table using AI-powered search.

Uses the existing table's config and validated data to plan a targeted row discovery run. The planner derives search strategy from the config, then RowDiscovery finds candidates and QC filters them.

If confirmed=False, returns a cost estimate. If confirmed=True, enqueues the discovery pipeline (planner -> search -> QC -> pending_rows).

Discovered rows land in pending_rows with source='row_discover'. Run add_validated_rows to validate them, or trigger a preview to see them.

Inputs: session_id (required), instruction (required), count, confirmed. Returns: result

exclude_rowA

Exclude a row from the full validation run.

Call with confirmed=False first to see a warning, then re-call with confirmed=True to apply. Reversible via include_row at any point before approving the full validation run.

Inputs: session_id (required), row_key (required), confirmed. Returns: result

get_balanceA
Read-only

Return the current account credit balance in USD.

Inputs: no named parameters. Returns: result

get_conversationA
Read-only

Poll a conversation for new messages or a status change.

Key statuses: processing → poll again in ~15s user_reply_needed → send_conversation_reply trigger_execution → preview is auto-queued; switch to get_job_status

Inputs: conversation_id (required), session_id (required). Returns: result

get_job_messagesA
Read-only

Fetch live progress messages for a running job.

Pass since_seq from the last message to receive only new messages.

Inputs: job_id (required), since_seq. Returns: result

get_job_statusA
Read-only

One-shot job status check. Prefer wait_for_job for tracking long-running jobs.

Use this for quick status inspections or as a fallback when wait_for_job is not appropriate. For polling loops, wait_for_job is more efficient — it holds the connection, emits live MCP progress notifications, and handles the multi-phase pipeline (table-maker → preview) automatically.

Key statuses: queued / processing → call wait_for_job instead of re-polling manually preview_complete → approve_validation (or refine_config) completed → get_results failed → check error field

Inputs: job_id (required). Returns: result

get_preview_stateA
Read-only

Get the current structural editing state of a session.

Returns the preview table, excluded rows, pending rows, ignored columns, and current row order so you can review before triggering the full validation run.

Inputs: session_id (required). Returns: result

get_resultsA
Read-only

Fetch the final validated/enriched results for a completed job.

job_id: the session_id value — "job_id" and "session_id" are the same string.

Automatically downloads table_metadata.json and embeds it inline so no separate HTTP fetch is needed. Key fields in the response:

results.markdown_table — START HERE. Self-contained markdown document: full validated table (all rows, all values), confidence icons, viewer/download links, and a guide to navigating citations. Read this first. results.metadata.rows[] — per-row data keyed by row_key; each cell has value, confidence, comment (with citations). (legacy files may use full_value; both are equivalent) results.interactive_viewer_url — share with humans; renders sources + confidence. results.download_url — enriched Excel file for offline sharing.

Inputs: job_id (required). Returns: result

get_usageA
Read-only

Return API usage history. Dates in YYYY-MM-DD format.

Inputs: start_date, end_date, limit, offset. Returns: result

include_rowA

Re-include a previously excluded row.

No confirmation needed. Can be called at any point before approving the full validation run.

Inputs: session_id (required), row_key (required). Returns: result

patch_columnA

Add a new column to a completed validation table.

If confirmed=False, returns a cost ceiling estimate (max-case: all rows x all columns x per_cell_cost x 1.25; likely much less if run within 1 day of original validation due to cache).

If confirmed=True, adds column header to source Excel, runs validation with updated config (old columns hit cache, new column fully validated), merges new column results into output Excel. No QC on column patch runs (single-column QC is not meaningful; full-table QC ran on the original validation).

Only available after full validation completes (status=completed).

Inputs: session_id (required), column_name (required), validation_target (required), confirmed. Returns: result

refine_configA

Refine the generated validation config using natural language instructions.

Example instructions: 'Add a column for LinkedIn URL. Remove the revenue column. Make email validation stricter.'

Set defer_preview=True if you plan to do structural editing (exclude_row, add_pending_row, etc.) before the preview — this prevents a premature auto-preview from firing before your edits are complete.

Inputs: conversation_id (required), session_id (required), instructions (required), defer_preview. Returns: result

reorder_preview_rowsA

Set the output row order for the validation run.

This is a display preference — it does not affect which rows are validated or the validation itself. Rows not in the list are sorted to the end.

Inputs: session_id (required), row_keys_in_order (required). Returns: result

send_conversation_replyA

Send a user reply in an ongoing conversation (interview or table-maker).

After sending, poll get_conversation for the AI's next response.

Inputs: conversation_id (required), session_id (required), message (required). Returns: result

start_reference_checkA

Submit a reference-check job to fact-check text or a document.

For inline text: start_reference_check(text="The claims to fact-check...")

For a PDF or document, upload it first then pass the s3_key: upload_file(file_path, file_type="pdf") → returns s3_key start_reference_check(s3_key=s3_key) Do NOT call start_table_validation for PDFs — that starts the table validation pipeline, which is not what you want for a reference check.

Designed for text with 4 or more factual claims; fewer claims may produce low-quality results.

Three phases:

  • Phase 1 (free): claim extraction + 3-row preview validation (auto-triggered). wait_for_job blocks until status=preview_complete. Review preview_table (3 validated sample claims) and cost_estimate.

  • Approval gate: call approve_validation to proceed.

  • Phase 2 (charged): full claim validation. Returns XLSX, viewer URL, metadata.

Set auto_approve=True to skip the approval gate and run straight through to completion automatically.

Inputs: text, s3_key, auto_approve. Returns: result

start_table_makerA

Start a Table Maker conversation to generate a research table.

Describe the table you want in natural language, e.g.: 'Create a table of AI startups that raised Series A in 2024 with columns: company name, funding amount, investors, product description.'

auto_start: When True, the AI skips the confirmation step and generates the table immediately from the message alone, without asking clarifying questions or showing a structure for approval. Use when the message fully describes the desired table and no back-and-forth is needed.

Inputs: message (required), auto_start. Returns: result

start_table_validationA

Confirm the upload and detect matching prior configs.

Call this immediately after upload_file completes (or after the curl upload finishes when using HTTP/Railway transport). Returns config_matches with match_score — if score >= 0.85 a prior config can be reused directly.

instructions: Optional natural-language description of what to validate and how (e.g. "This table lists clinical trials — validate that trial IDs, phase, and primary endpoints are accurate"). When provided, the upload interview is bypassed: the AI reads the table structure + instructions and generates a config directly without asking clarifying questions. Preview is auto-triggered immediately after.

config_id: Optional ID of a known prior configuration to reuse directly. When provided, skips matching and the interview entirely — applies the config and queues the preview immediately. Response includes preview_queued=true and job_id. Use when you already know the config_id (e.g. from a previous job's get_results response).

Config generation and the 3-row preview are free. Full validation is charged at approve_validation — you still see the cost at preview_complete before anything is billed. If balance is insufficient at that point, approve_validation returns an insufficient_balance error.

Inputs: session_id (required), s3_key (required), filename (required), instructions, +1 more. Returns: result

trigger_previewA

Trigger a preview run after structural editing is complete.

Call this after finishing row/column edits (exclude_row, add_pending_row, add_column, etc.) to explicitly queue a preview job.

This clears skip_auto_preview and queues the preview. Then call wait_for_job(session_id) to track progress.

Inputs: session_id (required). Returns: result

update_tableA

Re-run validation on a previously processed table (update in place).

source_version can pin a specific prior result version; omit for latest.

Inputs: source_job_id (required), source_version. Returns: result

upload_fileA

Upload a file to Subindex.

RECOMMENDED: always try with file_path first. If the server can read the file (stdio/uvx transport), it uploads in one step and returns session_id

  • s3_key immediately. If the server is remote (HTTP/Railway transport), file_path raises "File not found" — in that case call again without file_path to get a presigned S3 upload_url and curl_command instead.

With file_path (one step — stdio/uvx transport): upload_file(filename="data.xlsx", file_type="excel", file_size=12345, file_path="/abs/path/data.xlsx") → server reads + uploads → returns session_id, s3_key

Without file_path (two step — HTTP/Railway transport or any remote server): upload_file(filename="data.xlsx", file_type="excel", file_size=12345) → returns upload_url + curl_command → run the curl_command (requires shell/Bash access), then call start_table_validation(session_id, s3_key, filename)

Note: the two-step path requires shell access to run curl. If you have no shell (e.g. Claude Desktop), use the stdio/uvx transport instead so file_path works.

file_type must be one of: "excel", "csv", "pdf" The presigned URL expires in ~15 minutes — run curl immediately.

Inputs: filename (required), file_type (required), file_size (required), file_path, +1 more. Returns: result

wait_for_conversationA
Read-only

Wait for a conversation turn to complete, emitting live synthetic progress.

Preferred over manually polling get_conversation. Since conversation processing has no native progress signal, this tool emits time-based synthetic progress — advancing quickly at first, then slowing as it approaches expected_seconds — so the MCP host shows a "still thinking" indicator rather than a frozen bar.

Returns when any of these conditions are met: user_reply_needed=True → AI asked a question; call send_conversation_reply trigger_execution=True → AI approved execution; preview is auto-queued, switch to wait_for_job(session_id) Non-processing status → unexpected terminal (inspect status field) Timeout → returns last known state with _wait_timeout note

Applies to all conversation types: upload interview, table-maker interview, config refinement.

expected_seconds: typical AI response time for this turn (default 120). First table-maker turn (research + planning): ~120–180s. Upload interview first turn (CSV analysis + plan): ~90–150s. Follow-up confirmations ("yes, proceed"): ~30–60s. poll_interval: seconds between status checks (default 8). timeout_seconds: max wall time before returning (default 900). Upload interview turns can take up to 15 minutes — set accordingly.

Inputs: conversation_id (required), session_id (required), expected_seconds, timeout_seconds, +1 more. Returns: result

wait_for_jobA
Read-only

Wait for a job to reach a terminal state, emitting live MCP progress notifications.

Preferred over manually looping get_job_status. The MCP host shows a live progress indicator while this tool holds the connection — no extra token cost.

Architecture ──────────── Every poll cycle does two things in sequence:

  1. Fetch /messages → extract native progress %, emit MCP notification

  2. Fetch /status → act on phase transitions or terminal states

This separation means messages drive the visual indicator (they are more real-time) while status is the authoritative source for workflow transitions. Neither endpoint is used as a shortcut to skip the other; both are polled every cycle so transient failures in one don't cause false terminations.

Progress is always monotonically non-decreasing. Within a phase, msg_progress can oscillate (e.g. QC triggers new row-discovery rounds in the table-maker), but the emitted value is clamped to last_emitted. Across phases a geometric slice scheme is used so the bar never goes backward regardless of how many phases occur.

Progress geometry (lazy split) ────────────────────────────── Starts with the full 0–99 range so single-phase jobs (e.g. full validation after approve_validation) map their native 0–100% directly across the whole bar. On each intermediate phase transition, 80% of the current range is "spent" on the completed phase and the remaining 20% is handed to the next phase — keeping progress monotonic for any number of QC re-discovery rounds or pipeline stages. True terminal always emits exactly 100.

Terminal states: preview_complete, failed, completed-without-intermediate-step. Intermediate: completed + current_step in (Config Generation, Table Making, Claim Extraction, …) — tool advances phase and keeps polling.

Returns the same payload shape as get_job_status so downstream tools (approve_validation, get_results, etc.) apply directly.

job_id: the session_id value returned by upload_file / start_table_validation / start_table_maker. "job_id" and "session_id" are the same string — every workflow uses session_id as its job identifier throughout the pipeline. timeout_seconds: max wall time before returning last known state (default 900). Upload-interview + config-gen phases and large table previews can take up to 15 minutes — set timeout_seconds=900 or higher for long-running jobs. poll_interval: seconds between poll cycles (default 10) warmup_seconds: when > 0, applies synthetic sqrt-curve progress from 0→70% over this many seconds during the pre-message phase (before the first progress message or intermediate step arrives). Use this when the pipeline has a silent setup phase (e.g. instructions= mode where the backend runs an internal AI interview + config generation before preview messages begin). The warmup is automatically disabled once the first intermediate step completes (phase-split takes over). For instructions= mode, pass 300.

Inputs: job_id (required), timeout_seconds, poll_interval, warmup_seconds. Returns: result

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A4.2/5.0

    Scored across 25 tools

    Disambiguation5/5

    Each tool targets a distinct aspect of the validation pipeline—row management, job control, configuration, results, and account info—with no overlapping purposes. Even similar tools like add_pending_row vs add_validated_rows are clearly differentiated by stage.

    Naming Consistency5/5

    All 25 tool names follow a consistent verb_noun pattern (e.g., add_pending_row, get_results, wait_for_job). The naming is uniform and predictable, making it easy to infer functionality.

    Tool Count4/5

    With 25 tools, the set is on the higher side but each tool is justified by the server's comprehensive workflow (upload, config, preview, editing, validation, results, updates, and account management). Some consolidation of polling tools might be possible, but overall the count is reasonable for the scope.

    Completeness5/5

    The tool surface covers the entire lifecycle: file upload, table configuration, preview, structural editing, approval, full validation, result retrieval, post-validation updates, and even reference checking. Account tools (get_balance, get_usage) are also included, leaving no obvious gaps for the stated domain.

    Maintenance

    ActivityInactive
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      D
      maintenance
      Enables iterative deep research by integrating AI agents with search engines, web scraping, and large language models for efficient data gathering and comprehensive reporting.
      13 npm
      325
      MIT
    • A
      license
      A
      quality
      D
      maintenance
      A multi-agent research system that decomposes complex queries into targeted sub-questions, searches the web in parallel, scores source credibility, and synthesizes findings into structured markdown reports.
      1
      1
      MIT