io.github.futuresearch/everyrow-mcp

Check task status and display a live progress widget. Returns a progress widget that auto-updates via REST polling. The widget handles both progress tracking and result display. After calling this once, do NOT call futuresearch_progress — the widget polls automatically. Only call futuresearch_results if the user explicitly asks to see or discuss the results in the chat.

List futuresearch sessions owned by the authenticated user (paginated). Returns session names, IDs, timestamps, and dashboard URLs. Use this to find past sessions or check what's been run. Results are paginated — 25 sessions per page by default.

Check the current billing balance for the authenticated user. Returns the account balance in dollars. Use this to verify available credits before submitting tasks.

Get the billed cost of a completed task. Returns the amount charged in dollars. There is a delay between task completion and cost calculation. Returns 'pending' if the cost hasn't settled yet.

List all tasks in a session with their IDs, statuses, and types. Use this to find task IDs for a session so you can display previous results with mcp__display__show_task(task_id, label).

Cancel a running futuresearch task. Use when the user wants to stop a task that is currently processing.

Request a presigned URL to upload a local CSV file. Use this to upload a file from your local filesystem or sandbox. This is the recommended way to ingest local files in HTTP mode. Steps: 1. Call this tool with the filename (and optionally session_id to add to an existing session) 2. Execute the returned curl command to upload the file 3. Parse the JSON response to get the artifact_id and session_id 4. Pass the artifact_id to any processing tool (futuresearch_agent, etc.)

Browse available reference lists of well-known entities. Includes company lists (S&P 500, FTSE 100, Russell 3000, sector breakdowns like Global Banks or Semiconductor companies), geographic lists (all countries, EU members, US states, major cities), people (billionaires, heads of state, AI leaders), institutions (top universities, regulators), and infrastructure (airports, ports, power stations). Use this when the user's analysis involves a well-known group that we might already have a list for. Returns names, fields, and artifact_ids to pass to futuresearch_use_list. Call with no parameters to see all available lists. Prefer browsing the full list (~60 lists) over using search or category filters, which require advanced knowledge of what is there.

Import a reference list into your session and make it available via artifact_id for other futuresearch tools. This copies the dataset into a new session and returns an artifact_id that can be passed directly to other futuresearch tools (futuresearch_agent, futuresearch_rank, etc.) for analysis or research. The copy is a fast database operation (<1s) — no polling needed.

Run web research agents on each row of a CSV file. The dispatched agents will search the web, read pages, and return the requested research fields for each row. Agents run in parallel to save time and are optimized to find accurate answers at minimum cost. `task` describes WHAT to research in natural language. `response_schema` defines the OUTPUT STRUCTURE as a JSON Schema. If omitted, results default to a single {"answer": string} field. Pass it whenever you need typed or multi-field output. Do NOT describe desired output columns only in `task` — the schema is what controls the output structure. Examples: - "Find this company's latest funding round and lead investors" - "Research the CEO's background and previous companies" - "Find pricing information for this product" This function submits the task and returns immediately with a task_id. Then immediately follow the instructions in the response to monitor progress.

Deep parallel research: deploys multiple agents on different angles, then synthesizes. Use this instead of futuresearch_single_agent when either (a) completeness matters — you're trying to find all items matching a criteria (e.g. "all AI startups in Europe") and a single agent will have poor recall, or (b) depth matters — the answer benefits from parallel investigation across genuinely distinct angles (sources, geographies, methodologies) that a single agent would weight unevenly. For list-generation tasks especially, directing agents at different slices (by region, by vertical, by time period) dramatically improves coverage before synthesizing. Works on a single question or across many rows of a dataset. Each input row is researched by several direction agents in parallel (3-6 depending on effort_level), each exploring a different angle. Their findings are then synthesized into a single, well-rounded result per row. `directions` allows you to specify up to 6 explicit research angles. Each should be a detailed, self-contained brief — not a short title. Short display labels are generated automatically. If not provided, directions are auto-generated based on effort_level. `response_schema` defines the OUTPUT STRUCTURE for the synthesized result. If omitted, results default to a single {"answer": string} field. This function submits the task and returns immediately with a task_id. Then immediately follow the instructions in the response to monitor progress.

Run a single web research agent on a task, optionally with context data. Unlike futuresearch_agent (which processes many CSV rows), this dispatches ONE agent to research a single question. The agent can search the web, read pages, and return structured results. `task` describes WHAT to research in natural language. `response_schema` defines the OUTPUT STRUCTURE as a JSON Schema. If omitted, results default to a single {"answer": string} field. Pass it whenever you need typed or multi-field output. Do NOT describe desired output columns only in `task` — the schema is what controls the output structure. **For list generation:** When the task asks for a list of items, set `return_table=True` and provide a `response_schema` defining the fields for each item. This returns a multi-row table instead of a single text blob. Examples: - "Find the current CEO of Apple and their background" - "Research the latest funding round for this company" (with input_data: {"company": "Stripe"}) - "What are the pricing tiers for this product?" (with input_data: {"product": "Snowflake"}) - "Find 15 AI startups in healthcare" (with return_table=True and response_schema: {"type": "object", "properties": {"name": {"type": "string"}, "description": {"type": "string"}, "url": {"type": "string"}}, "required": ["name", "description"]}) This function submits the task and returns immediately with a task_id. Then immediately follow the instructions in the response to monitor progress.

Score and sort rows in a CSV file based on any criteria. Dispatches web agents to research the criteria to rank the entities in the table. Conducts research, and can also apply judgment to the results if the criteria are qualitative. `task` describes how to score each row in natural language. `response_schema` optionally defines extra output columns as a JSON Schema. If omitted, only the score column is returned. Do NOT describe desired output columns only in `task` — the schema is what controls the output structure. Examples: - "Estimate this drug's peak annual sales in billions of dollars" - "What is this country's 5-year GDP growth rate as a percentage?" - "Score this candidate from 0 to 100 by fit for a senior engineering role" This function submits the task and returns immediately with a task_id. Then immediately follow the instructions in the response to monitor progress.

Remove duplicate rows from a CSV file using semantic equivalence. Dedupe identifies rows that represent the same entity even when they don't match exactly. The duplicate criterion is semantic and LLM-powered: agents reason over the data and, when needed, search the web for external information to establish equivalence. Examples: - Dedupe contacts: "Same person even with name abbreviations or career changes" - Dedupe companies: "Same company including subsidiaries and name variations" - Dedupe research papers: "Same work including preprints and published versions" This function submits the task and returns immediately with a task_id. Then immediately follow the instructions in the response to monitor progress. Args: params: DedupeInput Returns: Success message containing task_id for monitoring progress

Join two CSV files using intelligent entity matching. Merge combines two tables even when keys don't match exactly. Uses LLM web research and judgment to identify which rows from the first table should join those in the second. left = the table being enriched (ALL its rows appear in the output). right = the lookup/reference table (its columns are appended to matches). IMPORTANT defaults — omit parameters when unsure: - merge_on_left/merge_on_right: only set if you expect exact string matches on the chosen columns or want to draw agent attention to them. Fine to omit. - relationship_type: defaults to many_to_one, which is correct in most cases. For one_to_many and many_to_many, multiple right-table matches are joined with " | " in each added column. Examples: - Match software products (left, enriched) to parent companies (right, lookup): Photoshop -> Adobe. relationship_type: many_to_one (many products per company). - Match clinical trial sponsors (left) to pharma companies (right): Genentech -> Roche. relationship_type: many_to_one. - Join two contact lists with different name formats: relationship_type: one_to_one (each person appears once in each list). - Match a company (left) to its products (right): relationship_type: one_to_many (one company has many products; matched product names joined with " | "). - Match companies (left) to investors (right): relationship_type: many_to_many (companies share investors and vice versa; matched values joined with " | "). This function submits the task and returns immediately with a task_id. Then immediately follow the instructions in the response to monitor progress. Args: params: MergeInput Returns: Success message containing task_id for monitoring progress

Forecast questions about the future using deep research and multi-model ensemble. Supports three modes: - **binary** (default): Forecasts probability (0-100) for YES/NO questions. Output columns: ``probability`` (int, 0-100) and ``rationale`` (str). - **numeric**: Forecasts percentile estimates for continuous numeric questions. Requires ``output_field`` (e.g. ``"price"``) and ``units`` (e.g. ``"USD"``). Output columns: ``{output_field}_p10`` through ``{output_field}_p90`` (float), ``units`` (str), and ``rationale`` (str). - **date**: Forecasts date percentile estimates for timing questions. Requires ``output_field`` (e.g. ``"launch_date"``). Output columns: ``{output_field}_p10`` through ``{output_field}_p90`` (YYYY-MM-DD strings) and ``rationale`` (str). The CSV should contain at minimum a ``question`` column. Recommended additional columns: ``resolution_criteria``, ``resolution_date``, ``background``. All columns are passed to the research agents and forecasters. The optional ``context`` parameter provides batch-level instructions that apply to every row (e.g. "Focus on EU regulatory sources"). Leave it empty when the rows are self-contained. This function submits the task and returns immediately with a task_id. Then immediately follow the instructions in the response to monitor progress.

Classify each row of a dataset into one of the provided categories. Uses web research that scales to the difficulty of the classification. Each row is assigned exactly one of the provided categories. Examples: - "Classify each company by its primary industry sector" with categories ["Technology", "Finance", "Healthcare", "Energy"] - "Is this company founder-led?" with categories ["yes", "no"] - "Classify by Koppen climate zone" with categories ["tropical", "arid", "temperate", "continental", "polar"] Output columns added: the ``classification_field`` column (default: ``classification``) containing the assigned category. Optionally a ``reasoning`` column if ``include_reasoning`` is true. This function submits the task and returns immediately with a task_id. Then immediately follow the instructions in the response to monitor progress.

Upload data from a URL or local file. Returns an artifact_id for use in processing tools. Use this tool to ingest data before calling futuresearch_agent, futuresearch_rank, futuresearch_dedupe, futuresearch_merge, futuresearch_classify, or futuresearch_forecast. Supported sources: - HTTP(S) URLs (including Google Sheets — auto-converted to CSV export) - Local CSV file paths (stdio/local mode only — not available over HTTP) For local files over HTTP, use futuresearch_request_upload_url instead: 1. Call futuresearch_request_upload_url with the filename 2. Execute the returned curl command to upload the file 3. Use the artifact_id from the curl response in your processing tool Returns an artifact_id (UUID) that can be passed to any processing tool's artifact_id parameter. The data is stored server-side and can be reused across multiple tool calls.

Check progress of a running task. Blocks briefly to limit the polling rate. After receiving a status update with partial results, briefly comment on the new rows for the user, then immediately call futuresearch_progress again (passing the cursor from this response) unless the task is completed or failed.