Chat Interface

Natural language in, code out — Chat is your primary interface for working with SignalPilot agents. Describe what you want in plain language, and the agent responds with code, explanations, or edits.

Chat works across all modes (Agent, Hands-On, Ask), adapting its behavior based on the mode you’re in. It’s conversational, context-aware, and designed for iterative workflows.

How Chat Works

Open the chat panel

Click the Chat icon in the SignalPilot sidebar. The chat panel opens on the left or right side of your notebook.

Type your request

Describe what you want in natural language:

“Load my CSV file and show me the first 5 rows”
“Connect to my Postgres database and get total sales by region”
“Fix the error in the last cell and explain what went wrong”
“Make the plot use a log scale on the y-axis”

Use @mentions to explicitly reference cells, datasets, or databases. Example: @revenue_data Show distribution by region

Agent responds

Based on your current mode, the agent:

Agent Mode: Creates a plan, gets approval, executes code
Hands-On Mode: Suggests code for you to review and execute
Ask Mode: Explains without generating code

The agent remembers your conversation history and builds on previous context.

Iterate

Continue the conversation:

Ask follow-up questions
Request modifications
Add more context with @mentions
Switch modes if needed

Chat is designed for back-and-forth collaboration, not just single requests.

Chat Across Different Modes

Agent Mode
Hands-On Mode
Ask Mode

Behavior: Autonomous executionWhat happens:

You describe your goal
Agent creates a multi-step plan
Shows you the plan for approval
Executes automatically after approval

Example conversation:

You: "Download SPY data for last 5 years and calculate dollar-cost
     averaging with $1000 monthly investments"

Agent: [Creates plan with 5 steps]

You: [Reviews and clicks Approve]

Agent: [Executes all steps, creates cells, runs code, generates plots]

Best for: Complex analyses where you want the AI to handle execution

Behavior: Suggests code, you control executionWhat happens:

You describe what you want
Agent suggests code
You review and approve
You manually execute the code

Example conversation:

You: "Add error handling to the database query in cell 3"

Agent: [Shows suggested code with try-except block]

You: [Reviews, accepts suggestion]

You: [Manually runs cell 3 with Shift+Enter]

Best for: When you want to review every change before execution

Behavior: Read-only Q&AWhat happens:

You ask a question
Agent provides explanation
No code is generated or executed
You implement changes manually if desired

Example conversation:

You: "Why is this query slow?"

Agent: "Looking at cell 5, the query is doing a full table scan
       because there's no index on the date column. You could:
       1. Add an index: CREATE INDEX idx_date ON sales(date)
       2. Filter on an indexed column first
       3. Use date partitioning if available"

You: [Decides which approach to take and implements manually]

Best for: Learning, exploring, understanding before making changes

Using @Mentions for Context

@Mentions let you explicitly add context to your requests:

@Mention Cells

Reference specific cells by number or type:

@cell-3 Explain what this cell does

@cell-5 @cell-7 Refactor these to share common logic

@markdown-cells Summarize the analysis plan

When to use: Focus the AI on specific parts of your notebook

@Mention Datasets

Reference dataframes or variables in your kernel:

@revenue_data Show me the distribution by region

@customers @orders Join these on customer_id

@df What's the schema and row count?

When to use: Work with specific data without sharing entire kernel state

@Mention Databases

Reference configured database connections:

@postgres-prod Get the schema for users table

@snowflake-analytics Run this query: SELECT...

@mysql-dev List all tables

When to use: Query databases or reference schemas in your request

@Mention MCP Resources

Reference external context from MCP servers:

@dbt-models Show lineage for revenue_daily

@slack-data-team Find discussions about data quality

@jira-analytics Get tickets related to dashboard

When to use: Bring in institutional knowledge from external tools

Configure MCP

Learn how to connect MCP servers

Chat Features

Conversation History

Chat maintains history within your session:

Remembers context: Previous questions, generated code, discussed issues
Builds on prior work: “Now add a filter for last month” (knows what “it” refers to)
Session-scoped: History clears when you close the notebook (zero data retention)

Start a new conversation thread (button in chat panel) to reset history and begin with a clean slate.

Code Actions

When the agent generates code, you can:

Accept
Reject
Modify
Ask for Alternatives

Agent Mode: Code is added to notebook and executed automatically
Hands-On Mode: Code is added to notebook, you execute manually
Ask Mode: N/A (no code generation)

You: "Show me 2 other ways to do this"

Agent: [Provides alternative approaches with trade-offs explained]

Inline Actions

Click on code in chat to perform actions:

Copy to clipboard: Grab code without adding to notebook
Run in scratch cell: Test code without affecting your analysis
Explain: Ask the AI to break down what the code does
Debug: If code errors, ask AI to fix it

Example Conversations

Data Loading
Database Query
Debugging
Iteration & Refinement

Goal: Load and clean a CSV file

You: "Load sales_data.csv and show me the first few rows"

Agent: [Generates pd.read_csv code, runs it, displays head()]

You: "I see there are missing values in the revenue column.
     How should I handle them?"

Agent: "I see 342 rows (8% of data) have missing revenue.
       You have several options:
       1. Drop rows: df.dropna(subset=['revenue'])
       2. Fill with median: df['revenue'].fillna(df['revenue'].median())
       3. Fill with 0: df['revenue'].fillna(0)

       Which approach fits your analysis?"

You: "Use median. Then filter for revenue > 1000"

Agent: [Generates cleaning code with median fill and filter, runs it]

Goal: Query Postgres database

You: "@postgres-prod What tables are available?"

Agent: "Found 12 tables in your Postgres database:
       - customers (4.2M rows)
       - orders (8.5M rows)
       - products (1,200 rows)
       - ...

       What would you like to query?"

You: "Get total revenue by month for 2024"

Agent: [Generates SQL query, executes it, loads into dataframe]

You: "Now plot this as a bar chart"

Agent: [Generates matplotlib/plotly code, creates visualization]

Goal: Fix an error

You: "Cell 7 is throwing a KeyError. What's wrong?"

Agent: "Looking at cell 7, you're trying to access
       df['revenue_usd'] but that column doesn't exist.
       In cell 3, the column is named 'revenue_dollars'.

       You can either:
       1. Rename in cell 3: df['revenue_usd'] = df['revenue_dollars']
       2. Update cell 7 to use 'revenue_dollars'

       I recommend option 2 to maintain consistency."

You: "Fix it with option 2"

Agent: [Updates cell 7 to use correct column name]

Goal: Iteratively improve a visualization

You: "Plot revenue over time"

Agent: [Creates basic line plot]

You: "Make it use log scale on y-axis"

Agent: [Updates plot with log scale]

You: "Add a 7-day moving average"

Agent: [Adds rolling average line to plot]

You: "Use a dark theme and larger font"

Agent: [Applies style changes]

Each request builds on the previous result. The agent remembers context.

Chat Best Practices

Be conversational, not formal

Good: “Load my CSV and show me what’s in it”Also good: “Can you help me load sales_data.csv?”Unnecessary: “Please execute pandas read_csv function on sales_data.csv and display first n rows”Chat is designed for natural language. Speak like you would to a colleague.

Provide context when needed

Vague: “Fix the error”Better: “Cell 5 is throwing a TypeError. Can you help?”Best: “@cell-5 is throwing a TypeError on line 3. I think it’s related to the data type of the date column”The more context you provide, the more helpful the response.

Use follow-ups to iterate

Don’t try to describe everything upfront. Start simple and refine:

“Plot revenue over time”
“Make it a bar chart instead”
“Group by month rather than day”
“Add a trend line”

This iterative approach is faster and more natural than trying to specify everything in one long request.

Switch modes when needed

If you find yourself constantly rejecting suggestions in Agent Mode, switch to Hands-On Mode for more control.If you want to understand something before implementing, switch to Ask Mode first.The mode selector is always available in the chat panel.

FAQ

Does chat remember everything I say?

Within a session: Yes, chat maintains conversation history.Between sessions: No, history resets when you close the notebook.Data retention: SignalPilot follows a zero data retention policy. No conversation history is stored on SignalPilot servers.

Can I have multiple chat threads?

Yes! Click “New Thread” in the chat panel to start a fresh conversation while keeping previous threads available. This is useful for:

Exploring different approaches in parallel
Keeping separate contexts for different tasks
Starting fresh when conversation gets too long

What if the agent doesn't understand my request?

Try:

Rephrase: Use different words or break it into smaller requests
Add context: Use @mentions to reference specific cells or data
Be more specific: Instead of “analyze this,” say “calculate summary statistics and plot distributions”
Ask for clarification: “What information do you need to do this?”

Can I edit my messages after sending?

Not yet, but you can:

Send a follow-up message clarifying or correcting
Start a new thread with the corrected request
The agent will understand “Actually, I meant…” style corrections

How do I give feedback on agent responses?

Accept/Reject buttons: Direct feedback on code suggestions
Follow-up messages: “That’s not quite right, try…” teaches the agent
Explicit feedback: “Good! Use this pattern for future suggestions”

The agent learns from your feedback within the conversation.

Next Steps

Planning

Learn how agents create multi-step plans via chat

Context Management

Master @mentions and context orchestration

Available Tools

See what the agent can do with your requests

Agent Mode

Use chat with autonomous execution

Introduction

Getting Started

Integrations

Core Concepts

Chat Interface

Chat Interface

How Chat Works

Chat Across Different Modes

Using @Mentions for Context

Configure MCP

Chat Features

Conversation History

Code Actions

Inline Actions

Example Conversations

Chat Best Practices

FAQ

Next Steps

Planning

Context Management

Available Tools

Agent Mode

Introduction

Getting Started

Integrations

Core Concepts

​Chat Interface

​How Chat Works

​Chat Across Different Modes

​Using @Mentions for Context

Configure MCP

​Chat Features

​Conversation History

​Code Actions

​Inline Actions

​Example Conversations

​Chat Best Practices

​FAQ

​Next Steps

Planning

Context Management

Available Tools

Agent Mode

Chat Interface

How Chat Works

Chat Across Different Modes

Using @Mentions for Context

Chat Features

Conversation History

Code Actions

Inline Actions

Example Conversations

Chat Best Practices

FAQ

Next Steps