Skip to main content

​
Context Orchestration

Context is the foundation — SignalPilot’s agentic harness aggregates information from multiple sources to give AI agents the full picture of your data environment.
Context orchestration is what separates SignalPilot from general-purpose AI assistants like ChatGPT or IDE copilots. The AI doesn’t just see your code — it sees your data, your transformations, your discussions, and your institutional knowledge.

​
What is Context?

Context is all the information the AI needs to understand your request and provide accurate, relevant assistance:

Notebook State

  • Cell code and outputs
  • Kernel variables and dataframes
  • Execution history
  • Markdown documentation

Data Sources

  • Local files (CSV, Excel, Parquet)
  • Database schemas and metadata
  • Table relationships
  • Query performance history

Transformations

  • dbt models and lineage
  • SQL transformations
  • Documentation and tests
  • Column-level lineage

Institutional Knowledge

  • Slack discussions about data
  • Jira tickets and requirements
  • Past investigation notes
  • Known data quirks

​
How Context Works Across Modes

Different agent modes use context differently:
Context collection: AutomaticWhat the AI sees:
  • All notebook cells and outputs
  • Full kernel state (variables, dataframes)
  • All database connections
  • All MCP server connections (dbt, Slack, Jira)
Control: You approve the plan upfront, then the agent has full context to executeBest for: Complex investigations where you want the AI to have complete information

​
The Context Aggregation Stack

SignalPilot uses a multi-layered approach to gather context:
1

Layer 1: Notebook Context

Always available — Local notebook state
  • Cell code: All code cells and their contents
  • Cell outputs: Results, dataframes, visualizations
  • Kernel state: Active variables, imported libraries
  • Execution order: Which cells ran, when, and with what results
This is the baseline context available in all modes.
2

Layer 1.5: Local Files

Indexed automatically — CSV, Excel, Parquet, and other data files
  • Default indexed folders:
    • ~/SignalPilotHome/data/ (home workspace)
    • ./data/ (current working project directory)
  • @mention files: Type @ in chat to reference any indexed file
  • Add folders: Use the File Scanner tool in the left sidebar
This is the fastest way to get started — drop files in data/ and @mention them in chat.
3

Layer 2: Data Warehouse Context

Configured connections — Database metadata and query history
  • Schema information: Tables, columns, data types
  • Relationships: Foreign keys, joins, dependencies
  • Performance metrics: Query execution times, table sizes
  • Query history: Past queries and their patterns
Connect your data warehouse in Database Integrations to enable this layer.
4

Layer 3: Transformation Context (via MCP)

dbt integration — Model lineage and documentation
  • Model definitions: SQL transformations
  • Column-level lineage: Where data comes from and goes to
  • Tests and assertions: Data quality rules
  • Documentation: Model and column descriptions

Configure dbt

Connect dbt Cloud or Core for transformation context
5

Layer 4: Collaboration Context (via MCP)

Slack, Jira, Notion — Institutional knowledge and discussions
  • Slack threads: Relevant discussions about data or analyses
  • Jira tickets: Requirements, known issues, feature requests
  • Notion docs: Team documentation and procedures
  • Past investigations: Previous analysis notebooks

MCP Servers

Learn how to connect collaboration tools

​
Context Management in Practice

​
Automatic Context (Agent Mode)

In Agent Mode, SignalPilot automatically aggregates all available context: 
User: "Why did revenue drop 8% last week?"

SignalPilot gathers:
✓ Revenue dataframe in current notebook (Layer 1)
✓ Schema for revenue_daily table in Snowflake (Layer 2)
✓ dbt model that creates revenue_daily (Layer 3)
✓ Slack thread about A/B test launched last week (Layer 4)

Agent responds:
"I see you have revenue_daily loaded. I also found a Slack discussion
mentioning an A/B test that started last Tuesday. Let me investigate
both the data drop and potential A/B test impact..."

​
Explicit Context (Hands-On Mode)

In Hands-On Mode, you control what context the AI can access:
Checkbox selection:
  • Click checkboxes next to cells to add them to context
  • Only selected cells are visible to AI
  • Unselect to remove from context
Use case: Focus AI on specific analysis without exposing exploratory work

​
Context and MCP (Model Context Protocol)

SignalPilot uses MCP to connect to external context sources:
MCP (Model Context Protocol) is a standard for connecting AI agents to external data sources. Instead of copy-pasting information, the AI can directly query:
  • dbt Cloud/Core for model lineage
  • Slack for relevant discussions
  • Jira for tickets and requirements
  • Database metadata servers
  • Custom internal tools

MCP Deep Dive

Learn how MCP works and how to configure servers
Internal MCP Sidecar (automatically available):
  • Kernel operations (execute code, introspect state)
  • Database queries (schemas, performance, history)
  • Local files (notebooks, CSVs, configs)
External MCP Servers (you configure):
  • dbt Cloud/Core
  • Slack
  • Jira
  • Notion
  • Custom tools via MCP specification
MCP connections are:
  • Read-only by default
  • Explicitly authorized by you
  • Zero data retention (SignalPilot never stores data)
  • Local-first (queries run from your environment)
You control:
  • Which MCP servers to connect
  • What permissions to grant
  • When to allow external context

Security Details

Read about SignalPilot’s security architecture

​
Viewing Active Context

SignalPilot shows your current context in real-time:
1

Open Context Panel

Click the Context tab in the SignalPilot sidebar to see:
  • Selected cells
  • Active dataframes
  • Connected databases
  • MCP server connections
2

Review What's Shared

The panel shows exactly what the AI can see:
  • ✓ Green checkmarks for active context
  • ○ Gray circles for available but not shared
  • 🔒 Lock icons for permission-required resources
3

Modify Context

Click items to add/remove them from context:
  • Toggle cell selection
  • Disconnect databases
  • Revoke MCP permissions
  • Clear all context to start fresh
In Hands-On Mode, review the Context Panel before each request to ensure you’re sharing exactly what you intend.

​
Context Best Practices

Don’t: Share everything upfront “just in case”Do: Start with the minimum context needed, then add more if the AI needs itWhy: Focused context leads to more relevant, faster responses. The AI won’t get distracted by unrelated information.
Instead of: Selecting all cells that mention revenue_dataDo: Type @revenue_data in chat to explicitly share that dataframeWhy: @mentions are more explicit and easier to track than cell selection
Before sharing: Check what’s in selected cells, especially if they contain:
  • Customer PII
  • Financial data
  • API keys or credentials
  • Proprietary business logic
Remember: Even with zero data retention, it’s good practice to minimize sensitive data exposure
Workflow:
  1. Start in Ask Mode: “What context would help analyze this issue?”
  2. AI explains what it would need
  3. Switch to Hands-On Mode and share that specific context
  4. AI provides targeted assistance
Why: Lets you understand context requirements before sharing anything

​
FAQ

Within a session: Yes, context persists as long as the notebook is open and the kernel is running.Between sessions: No, context resets when you close the notebook. This is by design for privacy.Exception: Plans and notebook state are saved, so the AI can resume work where you left off.
Not directly. Each notebook has isolated context. However, you can:
  • Export dataframes to files and load them in other notebooks
  • Reference shared databases from multiple notebooks
  • Use dbt models as common context across analyses
Immediate action:
  1. Clear the context panel
  2. Start a new chat thread
  3. Review what was shared
Remember: SignalPilot follows zero data retention. No conversation history or data is stored on SignalPilot servers. Everything stays local.Prevention: Use Hands-On Mode for sensitive data and review context panel before each request.
Signs of too much context:
  • Slow response times (processing large context)
  • Irrelevant suggestions (AI distracted by unrelated info)
  • Generic responses (AI overwhelmed by options)
Solution: Reduce context to the minimum needed for your current task. You can always add more later.
Not yet, but this is on the roadmap. For now:
  • Document your typical context needs in a markdown cell
  • Create templates with common cell selections
  • Use @mention patterns consistently

​
Next Steps

Chat Interface

Learn how to use chat to work with context

Planning

See how planning uses context for multi-step tasks

Available Tools

Discover what tools the AI can use with your context

MCP Overview

Connect external context sources via MCP