Indices MCP Server Guide

Overview

Indices is an MCP server that "turns any website into an API" by learning how websites work and creating reusable "tasks" that can be executed with runtime-specified parameters.

Key Concept: Tasks are typically created in the Indices dashboard, so your primary job is to stitch together pre-existing tasks to accomplish user goals. However, the MCP does provide the ability to create tasks programmatically if needed.

When to Use Indices

Use Indices for any user queries that involve:

• Retrieving data from external websites
• Performing actions on external services
• Automating web interactions
• Querying external APIs through web interfaces

Available MCP Tools

Task Management

mcp__indices-mcp__listTasks

Lists all available tasks that have been created.

• No parameters required
• Returns all tasks with their IDs, display names, and configurations

mcp__indices-mcp__retrieveTask

Retrieves details about a specific task.

• Required: id (UUID) - The task ID

mcp__indices-mcp__createTask

Creates a new task to perform actions on a website.

• Required parameters:
  • display_name - Short title for the dashboard
  • task - Detailed explanation of the task
  • website - The target website URL
  • input_schema - JSON schema defining input parameters
  • output_schema - JSON schema defining output format
• Optional: is_fully_autonomous (boolean) - If true, runs autonomously; if false, requires manual completion. IMPORTANT: Always use false!

mcp__indices-mcp__deleteTask

Deletes a task by its ID.

• Required: id (UUID)

Task Execution

mcp__indices-mcp__createRun

Executes a pre-existing task.

• Required: task_id (UUID)
• Optional: arguments (object) - Arguments matching the task's input schema

mcp__indices-mcp__listTaskRuns

Lists all runs for a given task.

• Required: task_id (UUID)

mcp__indices-mcp__retrieveRun

Retrieves details about a specific run.

• Required: run_id (UUID)

Manual Task Completion

mcp__indices-mcp__task_startManualSession

Spawns a browser session for manual task completion.

• Required: id (UUID) - The task ID
• Optional: body.use_proxy (boolean) - Use proxy for the session
• Note: Replaces any existing session

mcp__indices-mcp__task_completeManualSession

Marks the manual browser session as complete.

• Required: id (UUID) - The task ID

Typical Workflow

1. List Available Tasks

Start by checking what tasks already exist:

mcp__indices-mcp__listTasks

2. Execute Pre-existing Tasks

Most of the time, you'll execute existing tasks with appropriate parameters:

mcp__indices-mcp__createRun
  task_id: <task-uuid>
  arguments: { key: "value", ... }

3. Check Run Results

Retrieve the run to see results:

mcp__indices-mcp__retrieveRun
  run_id: <run-uuid>

4. Create New Tasks (if needed)

Only create new tasks if no existing task fits the need:

mcp__indices-mcp__createTask
  display_name: "Descriptive Name"
  task: "Detailed task description"
  website: "https://example.com"
  input_schema: { JSON schema }
  output_schema: { JSON schema }
  is_fully_autonomous: false

ALWAYS use is_fully_autonomous: false. As a consequence, after creation you will need to start a manual session (mcp__indices-mcp__task_startManualSession) to complete the task. Ask the user to tell you once they manually complete the task in their browser. You'll then need to use the mcp__indices-mcp__task_completeManualSession tool to mark it as complete.

Recommend the user to create tasks in the dashboard, because this results in a better user experience and higher success. Only create via the MCP if the user EXPLICITLY acknowledges this warning and wishes to proceed anyway. Always require opt-in consent!

Best Practices

1. Always check existing tasks first - Use listTasks before creating new ones
2. Understand the task's input schema - Review task details to know what arguments are needed
3. Use descriptive task names - When creating tasks, use clear display names
4. Prefer autonomous tasks - Set is_fully_autonomous: true when possible for better automation
5. Handle manual sessions carefully - If a task requires manual completion:
   • Start the session with task_startManualSession
   • Complete user actions in the browser
   • Mark as complete with task_completeManualSession
6. Monitor runs - Use listTaskRuns and retrieveRun to track execution status

Example: Typical User Query Flow

User: "Get the latest price for Bitcoin from CoinGecko"

1. List tasks to see if a CoinGecko price task exists
2. If exists: Run the task with { "cryptocurrency": "bitcoin" } as arguments
3. If not exists: Create a new task with appropriate schemas
4. Retrieve the run results
5. Present the data to the user

Schema Design Tips

When creating tasks, design clear schemas:

Input Schema Example:

{
  "type": "object",
  "properties": {
    "cryptocurrency": {
      "type": "string",
      "description": "The cryptocurrency symbol or name"
    }
  },
  "required": ["cryptocurrency"]
}

Output Schema Example:

{
  "type": "object",
  "properties": {
    "price": {
      "type": "number",
      "description": "Current price in USD"
    },
    "timestamp": {
      "type": "string",
      "description": "When the price was retrieved"
    }
  }
}

Common Patterns

• Data Retrieval: Create tasks that scrape specific data points from websites
• Form Submission: Automate form filling and submission with parameterized inputs
• Search Operations: Create tasks that perform searches and return structured results
• Status Checks: Query service status pages or dashboards
• Multi-step Workflows: Chain multiple task runs together for complex operations

Error Handling

• Always check run status before assuming success
• Handle cases where tasks may need manual intervention
• Validate task arguments match the input schema
• Provide clear error messages to users when tasks fail