Skip to main content

​
Available Tools

Agent capabilities — SignalPilot agents use a suite of tools to interact with your notebook, access data, manage plans, and connect to external systems.
Tool availability depends on your agent mode and configuration. Agent Mode has access to all tools, while Hands-On and Ask modes have restricted or read-only access.

​
Tool Categories

Notebook Operations

Read, edit, run, and manage cells in your notebook

Data Access

Load datasets, query databases, inspect kernel state

Planning & Execution

Create plans, track progress, manage multi-step tasks

External Context (MCP)

Connect to dbt, Slack, Jira, and other external systems

​
Notebook Operations

Tools for reading and modifying notebook cells:
What it does: Inspects existing notebook cellsParameters:
  • cell_ids (optional): Specific cells to read
  • include_outputs (optional): Whether to include cell outputs
Returns: Cell contents, metadata, and optionally outputsExample use cases:
  • Understanding notebook structure before making changes
  • Reading code from specific cells to refactor
  • Checking what data is already loaded
Availability:
  • ✅ Agent Mode (automatic)
  • ✅ Hands-On Mode (for selected cells only)
  • ✅ Ask Mode (read-only)
What it does: Modifies code in an existing cellParameters:
  • cell_id: Which cell to edit
  • new_content: Updated cell code
  • description: What changed and why
Returns: Confirmation of editExample use cases:
  • Refactoring code in an existing cell
  • Fixing errors identified during execution
  • Adding error handling or logging
Availability:
  • ✅ Agent Mode (automatic after plan approval)
  • ✅ Hands-On Mode (with user approval)
  • ❌ Ask Mode (read-only)
For single-cell edits, consider using Inline Edit which is optimized for this workflow.
What it does: Executes a cell and captures outputParameters:
  • cell_id: Which cell to run
  • timeout (optional): Max execution time
Returns: Cell output (stdout, stderr, display data)Example use cases:
  • Executing code generated by the agent
  • Re-running cells after edits
  • Testing code before finalizing
Availability:
  • ✅ Agent Mode (automatic)
  • ⚠️ Hands-On Mode (you run cells manually)
  • ❌ Ask Mode (read-only)
In Hands-On Mode, the agent suggests code but doesn’t run it. You execute cells manually with Shift+Enter.
What it does: Removes cells from the notebookParameters:
  • cell_ids: List of cells to delete
  • reason: Why these cells are being removed
Returns: Confirmation of deletionExample use cases:
  • Removing obsolete code
  • Cleaning up failed experiments
  • Simplifying notebook structure
Availability:
  • ✅ Agent Mode (with explicit user approval)
  • ✅ Hands-On Mode (with user approval)
  • ❌ Ask Mode (read-only)
Agents rarely delete cells without explicit instruction. If you want to clean up, ask specifically: “Remove cells 3-5”
What it does: Gets high-level notebook overviewParameters: NoneReturns:
  • Total number of cells
  • Cell types (code, markdown)
  • Execution order
  • Key variables defined
Example use cases:
  • Understanding notebook structure before planning
  • Identifying where to insert new code
  • Finding relevant cells for a specific task
Availability:
  • ✅ All modes (always available)
This tool is often used automatically by agents to gather context before responding.

​
Data Access

Tools for working with data:
What it does: Searches for datasets online (e.g., Yahoo Finance)Parameters:
  • query: Dataset name or ticker symbol
  • source: Data source (default: yahoo finance)
Returns: List of matching datasets with metadataExample use cases:
  • Finding stock price data: search_dataset("AAPL")
  • Looking up economic indicators
  • Discovering available data sources
Availability:
  • ✅ Agent Mode
  • ✅ Hands-On Mode (with approval)
  • ✅ Ask Mode (read-only search)
Example:
You: "What data is available for Tesla?"

Agent: [Uses search_dataset("TSLA")]
       "Found: TSLA stock prices (daily since 2010),
        options data, financials, news sentiment"
What it does: Downloads external datasetsParameters:
  • dataset_id: Dataset identifier from search
  • date_range (optional): Time period to download
  • save_path (optional): Where to save the data
Returns: Downloaded data as dataframeExample use cases:
  • Downloading stock prices
  • Fetching economic data
  • Loading public datasets
Availability:
  • ✅ Agent Mode (automatic)
  • ✅ Hands-On Mode (with approval)
  • ❌ Ask Mode (read-only)
Example:
# Agent uses download_dataset behind the scenes
spy_data = yf.download('SPY', period='5y')
What it does: Loads files from data folderParameters:
  • file_path: Path to CSV, Excel, Parquet, etc.
  • options (optional): pandas read options
Returns: Dataframe with loaded dataExample use cases:
  • Loading local CSV files
  • Reading Excel workbooks
  • Importing Parquet files
Availability:
  • ✅ All modes
Example:
You: "Load sales_data.csv"

Agent: [Uses read_dataset("sales_data.csv")]
       df = pd.read_csv('sales_data.csv')
What it does: Lists all files in data folderParameters: NoneReturns: List of available data files with metadata (size, type, modified date)Example use cases:
  • Discovering what data is available
  • Finding the right file to load
  • Checking if data exists before loading
Availability:
  • ✅ All modes
Example:
You: "What data files do I have?"

Agent: [Uses list_datasets()]
       "Found 3 CSV files:
        - sales_data.csv (1.2 MB, modified today)
        - customers.csv (3.4 MB, modified yesterday)
        - products.csv (45 KB, modified last week)"
What it does: Examines variables in the active kernelParameters:
  • variable_name: Name of variable to inspect
  • detail_level (optional): How much info to return
Returns:
  • Variable type
  • Value (or summary for large objects)
  • Shape/size (for dataframes/arrays)
  • Memory usage
Example use cases:
  • Checking dataframe schemas
  • Understanding what’s in a variable
  • Debugging type issues
Availability:
  • ✅ All modes
Example:
You: "What's in the revenue_data variable?"

Agent: [Uses inspect_variable("revenue_data")]
       "revenue_data is a pandas DataFrame:
        - Shape: (10,000 rows, 5 columns)
        - Columns: date, region, product, quantity, revenue
        - Memory: 390.6 KB
        - Date range: 2024-01-01 to 2024-12-31"

​
Planning & Execution

Tools for managing multi-step tasks:
What it does: Reads the current notebook planParameters: NoneReturns:
  • List of all steps
  • Completion status for each step
  • Current progress
Example use cases:
  • Checking what’s been completed
  • Understanding remaining work
  • Resuming after interruption
Availability:
  • ✅ All modes
Example:
You: "Where are we in the analysis?"

Agent: [Uses read_plan()]
       "Current plan progress:
        ✓ Load data (done)
        ✓ Filter for 2024 (done)
        → Calculate metrics (in progress)
        ○ Generate visualization (pending)
        ○ Export results (pending)"
What it does: Modifies the notebook planParameters:
  • new_steps (optional): Steps to add
  • remove_steps (optional): Steps to remove
  • reorder (optional): New step ordering
  • mark_complete (optional): Steps to mark as done
Returns: Updated planExample use cases:
  • Adding steps based on new findings
  • Removing obsolete steps
  • Marking manual work as complete
  • Reordering based on dependencies
Availability:
  • ✅ Agent Mode (automatic based on progress)
  • ✅ Hands-On Mode (with approval)
  • ⚠️ Ask Mode (can suggest changes but not apply them)
Example:
You: "Add a step to check for outliers before analysis"

Agent: [Uses update_plan(new_steps=[...])]
       "Updated plan:
        ✓ Load data
        ✓ Filter for 2024
        ○ Check for outliers (new step)
        ○ Calculate metrics
        ○ Generate visualization"

Learn More

See the full planning documentation

​
External Context (MCP)

Tools provided via Model Context Protocol servers:
What they do: Query databases and access metadataAvailable operations:
  • get_schema: Table and column information
  • execute_query: Run SQL queries
  • get_query_history: Past queries and patterns
  • get_table_stats: Row counts, sizes, last modified
Example use cases:
  • Understanding database structure
  • Running custom SQL queries
  • Finding relevant tables
Availability:
  • ✅ All modes (query execution requires approval in Hands-On)
Configuration:

Database Setup

Connect PostgreSQL, Snowflake, BigQuery, Databricks
Example:
You: "@postgres-prod What's the schema for users table?"

Agent: [Uses MCP get_schema("users")]
       "users table schema:
        - id (integer, primary key)
        - email (varchar, unique)
        - signup_date (timestamp)
        - plan (varchar)
        - status (varchar)"
What they do: Access dbt model lineage and documentationAvailable operations:
  • get_model_definition: SQL for a model
  • get_lineage: Upstream and downstream dependencies
  • get_model_docs: Documentation and column descriptions
  • get_tests: Data quality tests for a model
Example use cases:
  • Understanding how a table is created
  • Finding upstream data sources
  • Checking data quality rules
Availability:
  • ✅ All modes (read-only)
Configuration:

dbt Setup

Connect dbt Cloud or Core
Example:
You: "@dbt-models Show me lineage for revenue_daily"

Agent: [Uses MCP get_lineage("revenue_daily")]
       "revenue_daily lineage:
        Upstream:
        - raw.orders
        - raw.order_items
        - dim.products

        Downstream:
        - mart.revenue_monthly
        - reporting.dashboard_metrics"
What they do: Access Slack, Jira, Notion, etc.Available operations (Slack):
  • search_messages: Find relevant discussions
  • get_thread: Read a specific conversation
  • list_channels: Find where conversations happen
Available operations (Jira):
  • search_issues: Find relevant tickets
  • get_issue: Read ticket details
  • get_comments: Discussion on a ticket
Example use cases:
  • Finding context about data issues
  • Understanding requirements
  • Discovering known quirks or workarounds
Availability:
  • ✅ All modes (read-only)
Configuration:

Slack Setup

Connect Slack workspace

Jira Setup

Connect Jira project
Example:
You: "Why did revenue drop last week?"

Agent: [Uses MCP search_messages("revenue drop")]
       "Found Slack discussion from #data-team:
        'heads up - we launched an A/B test on pricing last
        Tuesday which is affecting ~10% of users'"

​
Tool Availability by Mode

Full access — All tools available
  • ✅ Read and write notebook cells
  • ✅ Execute code automatically
  • ✅ Download and load data
  • ✅ Update plans
  • ✅ Query databases (with configured connections)
  • ✅ Access MCP servers (dbt, Slack, Jira)
Control: You approve the plan, then agent uses all tools autonomously

​
FAQ

Not yet, but this is on the roadmap. Future versions will support:
  • Custom Python functions as tools
  • Custom MCP servers for internal systems
  • Team-specific tool libraries
Vote on this feature in our GitHub discussions.
In Agent Mode, the plan shows which tools will be used for each step.In Hands-On and Ask modes, the agent explains what it’s doing:
  • “Let me check the users table schema…”
  • “I’ll load the revenue data…”
  • “Searching Slack for relevant discussions…”
You can also check the execution log (coming soon) for detailed tool usage.
By mode:
  • Use Ask Mode to restrict to read-only tools
  • Use Hands-On Mode to require approval for each tool use
By configuration:
  • Disconnect databases you don’t want queried
  • Disable MCP servers you don’t want accessed
  • Don’t grant permissions when prompted
Granular per-tool restrictions are coming in a future release.
The agent will:
  1. Show you the error
  2. Explain what went wrong
  3. Suggest alternatives or fixes
  4. Pause execution (in Agent Mode) until you approve next steps
Example:
Tool Error: execute_query failed

"The query timed out after 30 seconds.
 This table has 500M rows and no index on date_column.

 Options:
 1. Add a filter to reduce rows
 2. Increase timeout
 3. Use a sample of the data instead

 Which would you prefer?"

​
Next Steps

Chat Interface

Learn how to request tool usage via chat

Context Management

Understand what context tools need to work

Agent Mode

See tools in action with autonomous execution

MCP Overview

Connect external tools via MCP