Tab Autocomplete

Context-aware code completion — SignalPilot’s Tab Autocomplete uses AI to suggest code based on your notebook context, not just syntax matching.

Unlike standard Jupyter autocomplete, SignalPilot’s AI autocomplete understands your variables, imported libraries, dataframe schemas, and coding patterns to generate smarter, multi-line suggestions.

How to Enable

Open SignalPilot Settings

Click the Settings icon in the SignalPilot sidebar (bottom right corner of the notebook interface).

Enable Tab Autocomplete

Find the Tab Autocomplete section and toggle it on.

The setting is saved automatically.

Reload your notebook

Close and reopen your notebook for changes to take effect (or reload the browser page).

Keyboard shortcut: Cmd+R (Mac) or Ctrl+R (Windows/Linux)

How It Works

Focus on a code cell

Click inside any code cell to edit it.

Pause typing for ~1 second

After you stop typing, the AI analyzes your context:

Variables already defined in the kernel
Imported libraries and their usage patterns
Code from other cells
Common patterns for the current task

The AI needs a brief pause to generate suggestions. Keep typing if you don’t want autocomplete.

Review the suggestion

A grayed-out completion appears inline with your cursor:

The suggestion might be:

A single line completing your current statement
Multiple lines for common patterns (e.g., for loops, try-except blocks)
Function calls with appropriate parameters

Accept or ignore

Accept: Press Tab to insert the suggestion
Accept partial: Press → (right arrow) to accept word by word
Ignore: Keep typing or press Esc to dismiss

Accepted completions become part of your code immediately.

Example Completions

DataFrame Operations
Multi-Line Patterns
Library Usage
Context from Other Cells

You type:

df.gro

AI suggests:

df.groupby('category').agg({'revenue': 'sum', 'quantity': 'mean'})

Why this is smart:

Knows df is a DataFrame (from kernel inspection)
Knows the column names (category, revenue, quantity)
Suggests appropriate aggregation functions
Uses common pandas patterns

You type:

for

AI suggests:

for item in revenue_data.iterrows():
    print(item['date'], item['revenue'])

Why this is smart:

Knows revenue_data exists in the kernel
Suggests iterating over rows (common notebook pattern)
Includes column names from the dataframe schema
Provides complete loop structure

You type:

plt.

AI suggests:

plt.figure(figsize=(12, 6))
plt.plot(df['date'], df['revenue'])
plt.xlabel('Date')
plt.ylabel('Revenue')
plt.title('Revenue Over Time')
plt.show()

Why this is smart:

Knows matplotlib is imported as plt
Knows you have date and revenue columns
Generates a complete, reasonable plot
Uses appropriate labels and titles

Previous cell:

sales_data = pd.read_csv('sales.csv')
sales_data['date'] = pd.to_datetime(sales_data['date'])

You type in new cell:

monthly

AI suggests:

monthly_sales = sales_data.groupby(pd.Grouper(key='date', freq='M')).sum()

Why this is smart:

Remembers sales_data from previous cell
Knows the date column was converted to datetime
Suggests time-based grouping (common next step)
Variable name monthly_sales matches the pattern

Tab Autocomplete vs Standard Autocomplete

Standard Jupyter Autocomplete
SignalPilot AI Autocomplete

How it works:

Matches local names and imported modules
Simple syntax completion
No context awareness
Single-line suggestions only

Example:

df.gro  →  df.groupby

Limitations:

Doesn’t know column names
Doesn’t suggest parameters
Can’t generate multi-line patterns
No understanding of your data

How it works:

Uses full notebook context
Understands data schemas
Multi-line suggestions
Pattern-aware completions

Example:

df.gro  →  df.groupby('category').agg({'revenue': 'sum'})

Advantages:

Knows your dataframe columns
Suggests appropriate aggregations
Can generate complete code blocks
Learns from your coding patterns

When Tab Autocomplete Helps Most

Repetitive pandas operations

Common scenarios:

Grouping and aggregation
Filtering with multiple conditions
Joining dataframes
Reshaping (pivot, melt, stack)

Example: Type df[ and get suggested filter based on your actual columns.

Boilerplate code

Common scenarios:

Try-except blocks
For loops over dataframes
Function definitions with common signatures
Import statements for standard libraries

Example: Type try: and get a complete try-except block template.

Visualization code

Common scenarios:

Matplotlib plot setup
Plotly figure configuration
Seaborn styling
Chart labeling and formatting

Example: Type plt.plot and get suggested plot with your dataframe columns.

Working with unfamiliar APIs

Common scenarios:

SQL query building
API request construction
Configuration file parsing
Data export formats

Example: Type df.to_ and get suggestions for common export formats (CSV, Excel, Parquet) with appropriate parameters.

Configuration Options

Enable/Disable
Suggestion Delay
Suggestion Length

Location: Settings panel → Tab Autocomplete toggleWhen to disable:

You find suggestions distracting
Working in a very slow environment
Prefer manual code writing for learning

Quick toggle: Settings are saved per-notebook (coming soon: global preference)

Tips for Better Completions

Use descriptive variable names

Good: monthly_revenue = ...Bad: df2 = ...The AI uses variable names as hints for suggestions. Descriptive names lead to better completions.

Keep cells focused

Good: One logical operation per cellBad: Mixing data loading, cleaning, and analysis in one cellCleaner cell structure helps the AI understand context and suggest relevant completions.

Import libraries consistently

Good:

import pandas as pd
import matplotlib.pyplot as plt
import numpy as np

Bad:

from pandas import *
import matplotlib.pyplot

Standard import conventions help the AI recognize patterns and suggest appropriate code.

Pause intentionally for complex completions

If you want multi-line suggestions (like entire function bodies), pause for 1-2 seconds instead of continuing to type.The AI will generate more complete suggestions when given time.

Privacy and Performance

Does autocomplete send my data to servers?

No. Autocomplete uses:

Local notebook context (cell code)
Variable names and types from kernel
Imported library information

Your actual data values are never sent to SignalPilot servers. The AI sees variable names and types, not the data itself.Example: The AI knows you have a dataframe called revenue_data with columns ['date', 'region', 'amount'], but it doesn’t see the actual revenue numbers.

Does it slow down my notebook?

Minimal impact. Autocomplete runs:

Asynchronously (doesn’t block typing)
Only after pauses (not while you’re actively typing)
With cached context (fast subsequent suggestions)

If you notice slowness:

Increase the pause delay in settings (coming soon)
Disable autocomplete temporarily
Check your internet connection (suggestions require API calls)

Does it work offline?

No. Tab autocomplete requires:

Active internet connection
SignalPilot API access

Fallback: Standard Jupyter autocomplete still works offline.

FAQ

Can I disable it later?

Yes. Go back to Settings → Tab Autocomplete and toggle it off. Changes take effect immediately (no reload required for disabling).

Does it work in all cells?

Code cells: Yes, full supportMarkdown cells: No, autocomplete is code-specificRaw cells: NoFuture versions may support markdown completions for documentation.

Why are some suggestions not relevant?

The AI makes suggestions based on:

Available context
Common patterns
Statistical likelihood

If suggestions seem off:

Check variable names: Are they descriptive?
Run cells above: The AI needs executed cells for kernel context
Be more specific: Type a bit more before pausing
Use Inline Edit instead: For very specific changes, ⌘K / Ctrl K might be better

Can it complete SQL queries?

Yes! If you’re writing SQL in Python strings (e.g., for SQLAlchemy or database connections), the AI can suggest query completions based on:

Your database schema (if connected)
Common SQL patterns
Table and column names

Example:

query = "SELECT "
# AI suggests: "SELECT * FROM users WHERE created_at > '2024-01-01'"

Does it learn from my coding style?

Within a session: Yes, the AI adapts to patterns it sees in your current notebook.Across sessions: Not yet. Future versions will support:

Team-specific coding patterns
Personal style preferences
Common libraries and functions you use

Vote on this feature in our GitHub discussions.

Next Steps

Inline Edit

Make targeted cell edits with natural language

Agent Mode

Use AI for multi-cell generation and execution

Chat Interface

Describe what you want and let AI write the code

5-Minute Quickstart

Complete your first analysis with SignalPilot

​Tab Autocomplete

​How to Enable

​How It Works

​Example Completions

​Tab Autocomplete vs Standard Autocomplete

​When Tab Autocomplete Helps Most

​Configuration Options

​Tips for Better Completions

​Privacy and Performance

​FAQ

​Next Steps

Inline Edit

Agent Mode

Chat Interface

5-Minute Quickstart

Tab Autocomplete

How to Enable

How It Works

Example Completions

Tab Autocomplete vs Standard Autocomplete

When Tab Autocomplete Helps Most

Configuration Options

Tips for Better Completions

Privacy and Performance

FAQ

Next Steps