Connect external tools to Productboard Spark

Note: Productboard Spark is currently in open beta and available to all customers. The beta is a standalone experience that doesn't integrate with existing Productboard workspaces. 

If you're on an Enterprise plan and workspace integration is important to you, contact your Productboard representative to discuss options. Otherwise, you can join the Spark beta here.

Spark connectors let you bring context from external tools directly into your conversations. Instead of switching between platforms, you can query live data, retrieve documents, analyze your codebase, and take actions through natural conversation.

For a refresher on how context works in Spark, see Context management in Spark.

In this article:

• Connection method overview
• Security and permissions for all connection methods
• MCP connectors
  • Available MCP connectors
  • Setting up MCP connectors
  • Custom MCP connectors
  • Current limitations
• File attachment connectors
  • Setting up file attachment connectors
  • Supported file types
  • Pasting page URLs directly into the chat field
  • Current limitations
• GitHub integration (codebase analysis)
  • Prerequisites and permissions
  • Setting up the GitHub integration
  • Managing repositories
  • What Spark can do with codebase access
  • Scope of access
• Public documentation
  • Adding a documentation source
  • Managing your sources
• Best practices and tips for best results
• See also

Connection method overview

Four connection methods are available:

• Model Context Protocol (MCP) connectors: Query live data from tools like Amplitude, Linear, and Notion through conversation. For example: "Go to Amplitude and show me engagement metrics for the new onboarding flow."
• File attachment connectors: Attach documents from Confluence or Google Drive to use as context. For example: attach your competitor analysis doc, then ask Spark to "generate three feature ideas that will help us capture market share."
• Codebase analysis (GitHub integration): Ask plain-language questions about your product's actual behavior, with answers sourced directly from your connected GitHub repositories. For example: "What are the file upload limits?" or "What permissions does a viewer need to export data?".

• Help center articles: Connect your existing help center or product documentation so Spark can draw on your product's terminology, features, and workflows. Spark indexes all publicly accessible articles at the URL you provide and automatically uses them as context whenever relevant — no prompting needed.

Think of it this way: with MCP connectors, you ask Spark to find and retrieve information on your behalf, and it decides how to get what you need. With file attachments, you select exactly which documents to include, meaning you control what Spark sees. With codebase analysis, Spark reads directly from production code to answer questions about how your product actually works.

When to use each method

Security and permissions

Connected tools respect your existing permissions in external systems. Spark can only access data and perform actions that your user account is authorized to do in each connected tool. When you connect a tool, you're granting Productboard Spark permission to act on your behalf within the scope of your account permissions.

This applies to all MCP and file attachment connections.

MCP connectors

MCP connectors allow Spark to connect to external tools and services. Once connected, you can interact with these tools through natural conversation without leaving Spark.

Examples of what you can do:

• "Show me the latest analytics from Amplitude for feature X."
• "Create a Linear task to investigate this performance issue."
• "Pull the latest customer feedback from Notion."

Available MCP connectors

If a connector you need isn't on this list, submit a request here.

Setting up MCP connectors

To set up an MCP connector:

1. From any Spark chat, click Integrations > Add connectors.
   
   
    
2. In the list, find the tool you want to connect. Click its name to review its details if you wish, then click Connect.
   
   
    
3. You'll be redirected to that tool's login page. Follow the instructions on-screen to review the content Spark can access based on your account permissions and grant Spark permission to access your data. When finished, you'll be redirected back to Productboard.

The MCP connection is now active and available across all Spark chats. To use it, simply invoke it in a Spark chat.

Custom MCP connectors

If you'd like to set up your own MCP connection:

1. From any Spark chat, click Integrations > Add connectors > Add custom connector.
2. Enter the MCP server URL.
3. Follow the instructions on-screen.

Note: Spark does not support SSE protocol connectors (legacy MCP server implementation). Furthermore, all custom MCP connectors are required to have authentication, otherwise they cannot be added.

Current limitations

• MCP connectors with write permissions (create, edit, and delete actions) may execute changes without explicit confirmation prompts, which could result in unintended modifications to your connected tools.
• Custom connectors are available but should be used with caution. Only connect servers from trusted sources (like those listed on official vendor websites) and review requested permissions carefully, as unverified connectors could access more data than intended or behave unexpectedly.

File attachment connectors

File attachment connectors let you attach files from your documentation platforms directly into Spark conversations. This provides strategic context that helps Spark deliver more relevant and accurate AI responses.

• Supported platforms: Confluence, Google Drive, Notion
• Coming soon: SharePoint

Setting up file attachment connectors

To set up a file attachment connector:

1. From any Spark chat, click Integrations.
2. Select the documentation platform you wish to connect with.
   
   
    
3. Follow the instructions on-screen to review which content Spark can access based on your account permissions and grant Productboard Spark permission to access your data.

Note for administrators: Your organization may need to approve Productboard Spark before users can connect. If users encounter access errors, check your settings within the respective platform's admin console.

• Google Workspace: Administrators control third-party app access in the Admin console. See Control which apps access Google Workspace data.
• Confluence: Atlassian administrators may need to approve the Productboard Spark app in your organization's settings. See Manage your organization's Marketplace and third-party apps.
• Notion: Instructions for managing API access in Notion can be found here: Add & manage integrations.

The file attachment connector is now active and available across all Spark chats. To use it, click @ Context above the chat input field, then search the service for the documents you want to attach. You can attach multiple documents.

Remember that file attachments are only used for context in chats where they're added. If you start a new chat and want to reference those same documents, you need to add them as context again.

Supported file types

When attaching documents from Google Drive or Confluence, Spark supports the following file types:

• Google
  • Google Docs
  • Google Sheets
  • Google Slides
  • PDFs
  • Markdown
  • CSV
  • Plain text
• Confluence
  • Confluence pages
• Notion
  • Notion pages

Pasting page URLs directly into the chat field

Once you've set up your file attachment connectors, you can paste a URL directly into the Spark chat input. The URL automatically transforms into a visual chip displaying the document title and source icon. You can click the chip to open the original document if needed.

Spark can only handle one pasted link per chat message, so you can't place multiple links in the same message, and you can't paste links to folders, only individual pages.

Document content shared this way is immediately added to the conversation context, ready for Spark to reference in its responses.

Note: You can currently paste links to Notion and Confluence pages. Google Drive links are not yet supported.

Current limitations

• Attached documents are not persistently stored — they're attached per conversation. If you attach a document into one chat, it won't be available in another chat until you re-attach it.
• Multiple individual files can be attached, but entire folders cannot.
• You cannot type the "@" symbol to reference attached documents; you must click the @ Context button above the chat input field.
• Conversational search across external platforms is not yet available.
• Productboard administrators cannot currently manage which connectors and attachment sources are available to users in Spark.

GitHub integration (codebase analysis)

Spark becomes a genuine expert in your product when you connect it to your GitHub repositories. You can leverage this connection to better understand the existing product, generate high-quality product specifications grounded in real implementation, and have much more valuable discussions with your engineering counterparts.

Once the GitHub integration is installed for your workspace, Spark automatically draws on your codebase whenever it's relevant — for example, when helping you write a spec, answering a question about how a feature works, or assessing the feasibility of a change. You don't need to explicitly ask Spark to check the code; it decides on its own when codebase context will make a response more accurate and useful. 

The setup is a one-time process done by a workspace admin, and from that point on, codebase access is available to everyone in the workspace.

Prerequisites and permissions

To connect the GitHub integration, you need to be a Productboard admin. You also need a GitHub account with access to the organization and repositories you want to connect. 

For the best experience, you should also be an admin of that GitHub organization, or at least have a GitHub org admin available to complete or approve the installation.

Setting up the GitHub integration

Click below to see instructions relevant to your situation.

The connected organization appears in your GitHub integration settings with an Authorized status. Your selected repositories are indexed automatically every day, and you can update connected repositories at any time from the GitHub integration settings in Productboard.

Managing repositories

After installation, the connected GitHub organization appears in your Spark integration settings. Click the arrow next to the organization to open the repository management page. From there you can:

• Enable or disable indexing per repository using the toggle next to each one. Only enabled repositories are indexed and made available to Spark.
• Reindex a repository manually by clicking the Reindex button. This triggers an immediate re-index without waiting for the nightly automatic reindex. If a reindex is already in progress, wait for it to complete before triggering another.
• Synchronize repositories using the Synchronize repositories button (top right of the repository page). Use this if new repositories have been added to your GitHub organization since the initial connection.

Repositories are automatically re-indexed every night, so Spark always reflects the current state of your codebase.

To manage the connected organization itself, return to the main GitHub integration settings page. From there you can:

• Use the toggle to enable or disable the entire organization connection.
• Click Revoke to remove Spark's authorization for the organization while keeping the connection record.
• Click Delete to fully remove the connected organization from Productboard.

Note: Initial indexing after connecting a repository may take up to one hour. You can check the status for each repository on the repository management page.

What Spark can do with codebase access

Once your repositories are indexed, Spark can answer natural-language questions about how your codebase currently works. Key use cases include:

• Onboarding and domain discovery: Quickly understand how a new product area works without engineering walkthroughs. For example: "Give me an overview of how the billing system works."
• Technical constraints and limits: Look up real boundaries like file size limits, rate limits, and supported formats. For example: "What is the maximum file size users can upload?"
• Feature flag and rollout status: Identify which flags control a capability and how they affect behavior. For example: "Which feature flags control the new onboarding flow?"
• Analytics and instrumentation discovery: Find out which events are tracked and what properties they carry before designing metrics. For example: "What analytics events are fired when a user completes onboarding?"
• Spec writing grounded in current implementation: Research the existing implementation so your specs reflect reality, not assumptions. For example: "Help me write a spec for improving feature X. First, research how it currently works."
• Feasibility validation: Get a structured feasibility assessment before committing engineering resources. For example: "How complex would it be to add SSO support to the current authentication system?"
• Customer and engineering conversations: Get accurate, source-backed answers during customer calls or engineering discussions.

Scope of access

Productboard has read-only access to your repositories. Spark can read and analyze your code, but it cannot create branches, open pull requests, commit changes, or modify anything in your repositories. Read-only access is intentional: it keeps your codebase safe while giving Spark everything it needs to be genuinely useful.

Note: Only GitHub is supported at this time. GitLab, Bitbucket, and other repository hosts are not currently supported.

Public documentation

Spark can draw on your existing knowledge base and product documentation to better understand your product's terminology, features, and functionality. Once your add your documentation's URL, Spark indexes all publicly available articles at that address and automatically uses them as context whenever they're relevant to your conversation, without you needing to prompt it explicitly.

This is a workspace-level setting, so a Productboard admin only needs to configure it once for the entire workspace.

Adding a documentation source

Note: If your Productboard workspace was created after April 2026, your documentation may already be connected. During sign-up, you provided a website URL. Productboard uses this to automatically add your public documentation as a source. You can find it listed in Workspace settings > Help center articles and remove it there if needed.

To connect a documentation source to Spark:

1. In Productboard, go to Workspace settings > Help center articles.

2. Enter the URL of your help center or documentation site in the input field and click Add URL. The URL must be publicly accessible; Spark cannot index content behind a login or paywall.
   
   

Once added, Spark begins indexing the articles at that URL. You can add multiple sources, which is handy if you maintain separate documentation for different products, APIs, or integrations. There is no limit on the number of sources you can add.

Managing your sources

For each added source, you can:

• See the indexing status: Check whether the source has been successfully indexed and when it was last updated.

• Reindex manually: Trigger an immediate re-index if you've recently updated your documentation and want Spark to reflect the latest content without waiting for the automatic refresh.

• Remove a source: Delete the source from Spark's context entirely.

Sources are automatically re-indexed every night, so Spark always reflects your latest documentation.

Best practices and tips for best results

Here's how you can get the most out of your connectors:

Structure your data systematically

• Use clear and consistent naming conventions for documents, features, and projects (e.g., "PRD: [Feature Name]" not "feature doc v3 final").
• Create clear folder hierarchies in documentation platforms.
• Well-organized data means better AI retrieval and more accurate responses.

Maintain up-to-date documentation

• Archive outdated documents rather than deleting them.
• Mark documents with status indicators (Draft, In Review, Approved, Deprecated).

Connect your most-used tools first

• Start with three to five core tools rather than connecting everything at once.
• Focus on tools you query daily: analytics, project tracking, and documentation.
• Add specialized connectors as specific needs arise.

Specify which connector to use

• When using MCP connectors, explicitly name the tool you want Spark to query:
  • ✅ "Go to Amplitude and show me engagement metrics for the new onboarding flow."
  • ✅ "Search Notion for the product brief for the new home feature."
  • ✅ "Check Linear for all high-priority bugs in the authentication epic."

Use clear language, context, and punctuation

• End questions with "?" to signal you're seeking information vs. giving commands.
• Place key terms in quotes: "Show me customer tickets mentioning 'authentication bug' from Linear."
• Include relevant background information: "As we're planning Q2 roadmap, go to Linear and show me all features currently in development."

Specify the desired output format

• ✅ "Format as a table with columns: Feature, Customer Count, Business Impact."
• ✅ "Summarize in 3 bullet points."
• ✅ "Create a prioritized list with rationale for each item."

Use specific identifiers

• Reference exact project names, ticket IDs, or document titles.
• ✅ "Show Linear issue PB-1234" is faster than "find that bug about login."

See also

• Beta: Productboard Spark
• Prompt library for common Spark use cases
• Context management in Spark
• Spark prompts
• Customer feedback management in Spark
• Spark pricing and billing FAQ