# Authentication and SSO
Source: https://docs.fabi.ai/admin_and_configuration/auth_and_sso

Everything you need to know about logging in to Fabi.ai.

# Single sign on (SSO)

Fabi.ai only supports SSO login, we do not offer password-based login. The default SSO option is Gmail, whether you have a personal or corporate Gmail account.

# Multi-factor authentication (MFA)

Since we partner with SSO providers to provide our login experience, two-factor or multi-factor authentication is done through your provider. If you're using Gmail for example, setting up MFA is done in your Gmail settings.

# SCIM provisioning

Fabi.ai does offer SCIM provivioning for enterprise customers. If you're interested in learning more, please reach out to us as [hello@fabi.ai](mailto:hello@fabi.ai) and we'll be in touch and we'll work directly with your team to get you setup.
SCIM configuration typically takes about 30 minutes.


# Pricing & billing
Source: https://docs.fabi.ai/admin_and_configuration/pricing_and_billing

Fabi.ai plans, pricing, and subscription management.

# Plans

Fabi.ai offers four plans to fit teams of every size. All plans include 24/7 support and SOC2 compliance.

| Feature                              | Starter  | Builder          | Team             | Enterprise |
| ------------------------------------ | -------- | ---------------- | ---------------- | ---------- |
| **Price**                            | Free     | \$39/mo per seat | \$50/mo per seat | Custom     |
| **AI requests**                      | 25/month | 300/month        | Unlimited        | Unlimited  |
| **Smartbooks**                       | 5        | 10               | Unlimited        | Unlimited  |
| **Dashboard viewers**                | 10       | 25               | 50               | Custom     |
| **Database connectors**              | 1        | 1                | 2                | Unlimited  |
| **File uploads**                     | 50MB     | 100MB            | 500MB            | Custom     |
| **Application connectors**           | —        | ✓                | ✓                | ✓          |
| **Scheduled dashboards & workflows** | —        | ✓                | ✓                | ✓          |
| **Builder seats**                    | 1        | Up to 3          | 4+               | Unlimited  |
| **Custom security review**           | —        | —                | —                | ✓          |
| **Quarterly roadmap reviews**        | —        | —                | —                | ✓          |
| **Fractional data science team**     | —        | —                | —                | ✓          |
| Slack app                            | —        | —                | ✓                | ✓          |

Builder and Team plans include a **14-day free trial**.

For Enterprise pricing, [contact our sales team](mailto:support@fabi.ai).

# Application connector pricing

Application connectors (e.g. HubSpot, Shopify, Google Ads) are available on Builder plans and above and are priced separately from your seat subscription:

* **\$100/month per connector** — includes 200k record updates per month
* **Additional records**: \$50 per 100k records (prorated)
* **Overage limit**: We automatically set an overage cap of \$400 per connector (configurable in your settings). If you reach this limit, your sync will be paused and you'll receive an email notification.

<Info>
  The 200k monthly records included in the base price is sufficient for most connectors. High-volume sources like ads platforms, product event tracking, email tracking, or IoT data may exceed this limit.
</Info>

For questions about connector pricing, reach out to [support@fabi.ai](mailto:support@fabi.ai).

# Managing your subscription

## Upgrading or downgrading

To change your plan, navigate to **Settings → Billing** in your Fabi.ai workspace. From there you can:

* Upgrade to a higher tier at any time — changes take effect immediately
* Downgrade at the end of your current billing period
* Add or remove builder seats on Builder and Team plans

## Free trial

Builder and Team plans include a 14-day free trial. No credit card is required to start your trial. At the end of the trial period, you'll be prompted to enter payment details to continue.

## Cancellation

You can cancel your subscription at any time from **Settings → Billing**. Your account will remain active through the end of your current billing period, after which it will revert to the Starter (free) plan.

## Questions

For billing questions or issues, contact us at [support@fabi.ai](mailto:support@fabi.ai).


# User management
Source: https://docs.fabi.ai/admin_and_configuration/user_management

Managing users: Inviting, removing, roles.

# Inviting users

To invite users from your organization to your account, you can either:

1. Go to our User management page by navigating to it from the left hand menu and clicking on **Users**
2. Sharing a Fabi.ai link with them and letting them self-provisioning with their corporate email address

Note that if they create their account on their own, if you're a Fabi.ai paying customer, new users will be defaulted to **Viewers**. You can change their role once they've onboarded. Alternatively, if you invite a user through the Fabi.ai interface, you can specify their role before they log in.

<Frame>
  <img alt="Description" />
</Frame>

<Note>
  **Note on SCIM**: If you're on our Enterprise plan and you have SCIM provisioning configured, user creation is managed by your SCIM provider.
</Note>

# Changing user roles

A user can be in one of three roles:

1. **Admin**: Admins have complete Fabi.ai access. They can build and publish dashboards and workflows and manage users, billing and other organization-wide configurations.
2. **Builder**: Builders can create, publish and schedule Dashboards & data apps and workflows. Great for data analysts, data scientists, data engineer, product managers and anyone else who regularly builds dashboards.
3. **Viewer**: Viewers cannot create new Smartbooks or workflows. This role is great for users who only need to view published dashboards and workflows.


# Automatic versioning
Source: https://docs.fabi.ai/advanced_features_and_dev_tools/automatic_versioning

Smartbook and cell-level versioning

# Overview

To help you analyze and build with full peace of mind, Fabi automatically snapshots code at the Smartbook and cell level at certain key moments (for example when you accept AI suggestions).

# Reviewing and reverting Smartbook versions

To review and compare the diff between two Smartbook versions, click on `Revision History` in the Smartbook overflow menu.

In this modal, you'll be able to see all the automatically captured versions in the browser on the left. You can also compare any two versions by selecting the versions you want to compare in the dropdowns. If you want to revert the Smartbook to a previous version, simply find the version you want to revert to and click `Restore This Version`.

<Frame>
  <img alt="Version modal" />
</Frame>

# Reviewing and reverting cell versions

Version snapshots are even available at the cell level. This is convenient if you know you just made a change to a specific cell and want to just inspect the history for that one cell instead of the entire Smartbook.

Find the cell you want to inspect, and click on `View Versions` in the cell header.

This will open up a modal focused just on the versions of this specific cell.

<Frame>
  <img alt="Cell versions" />
</Frame>


# Fabi CLI
Source: https://docs.fabi.ai/advanced_features_and_dev_tools/cli

Use the Fabi CLI to build and deploy custom dashboards and apps from any AI coding agent

# Overview

The Fabi CLI gives you programmatic access to the Fabi back end from your terminal. Combined with an AI coding agent like [Claude Code](https://docs.anthropic.com/en/docs/agents-and-tools/claude-code/overview) or Codex, it enables a headless BI workflow — you can build fully custom dashboards and applications on top of your connected data sources, then deploy and share them through Fabi.

To get started, point your agent to the CLI repository:

```
https://github.com/fabi-ai/fabi-cli
```

Your agent will install the CLI and automatically redirect you to your browser to log in. Once authenticated, your agent has access to every data source connected to your Fabi workspace and you can immediately start building.

# What you can do

With the CLI installed, you can ask your agent to:

* Build custom dashboards with any layout, chart type, or interaction you can describe
* Create data applications (search tools, reporting interfaces, admin panels, etc.)
* Query any data source connected to your Fabi workspace
* Deploy finished apps to [app.fabi.ai](https://app.fabi.ai) and share them with your team

Your agent generates React applications from scratch on top of the Fabi API, so there are no template constraints — if you can describe it, your agent can build it.

# Example workflow

Everything happens through conversation with your agent:

1. **"Install the Fabi CLI from [https://github.com/fabi-ai/fabi-cli](https://github.com/fabi-ai/fabi-cli)"** — your agent clones the repo and installs the CLI. You'll be redirected to your browser to log in.
2. **"Build a dashboard showing our top 10 customers by revenue this quarter, with a bar chart and a detail table I can click into"** — your agent pulls your data context, generates a React app, and previews it locally.
3. **"Deploy this to Fabi"** — your agent deploys the app and gives you a link to share with your team.

<Tip>
  The more semantic context your team has configured in Fabi (column descriptions, metrics definitions, relationships), the better your AI agent will perform. See [AI context and semantics](/integrations_and_connectors/ai_context_and_semantics) for details.
</Tip>

# Security

You authenticate through Fabi, which manages session tokens on your behalf. Your underlying data source credentials are never exposed locally — there are no raw database tokens in `.env` files or shell histories.

* **No raw credentials locally** — you authenticate through Fabi's OAuth flow, and session tokens are managed by the CLI. Your database passwords and API keys never touch your local machine.
* **Scoped access** — the CLI respects the same permissions and data source access controls configured in your Fabi workspace.
* **Revocable sessions** — if a machine is lost or compromised, revoke the session from your Fabi account settings without needing to rotate database credentials.

# Supported agents

The Fabi CLI works with any AI coding agent that can execute shell commands, including:

* **Claude Code** — point it at the CLI repo and start building
* **Codex** — works the same way via its terminal access


# MCP Server
Source: https://docs.fabi.ai/advanced_features_and_dev_tools/mcp_server

Connect to Fabi through the Model Context Protocol (MCP) server

# Overview

Fabi.ai provides an MCP (Model Context Protocol) server that allows you to integrate Fabi's AI data analysis capabilities directly into your development workflow or your client/interface of choice. The MCP server enables AI assistants and development tools to interact with Fabi.ai, creating threads, submitting chat requests, and saving Smartbooks programmatically.

The Fabi MCP server is the single fastest way for you to implement an AI assistant to chat directly with your data.

# Authentication

The Fabi MCP server supports two authentication methods:

## Token authentication

Token authentication is the recommended method for programmatic access. You can generate MCP tokens from your Fabi.ai settings:

1. Navigate to [https://app.fabi.ai/settings/mcp](https://app.fabi.ai/settings/mcp)
2. Generate a new MCP token
3. Copy the token securely - it will only be shown once

## OAuth authentication

OAuth authentication is also supported for user-based integrations. Follow the OAuth flow to authenticate your application and use the following URL: `https://app.fabi.ai/mcp`

# Configuration

To connect to the Fabi MCP server, add the following configuration to your MCP client settings:

```json theme={null}
{
  "mcpServers": {
    "fabi": {
      "command": "npx",
      "args": [
        "mcp-remote",
        "https://app.fabi.ai/mcp",
        "--header",
        "Authorization: Bearer <your-fabi-mcp-token>"
      ]
    }
  }
}
```

Replace `<your-fabi-mcp-token>` with the token you generated from the settings page.

# Available tools

The Fabi MCP server provides the following tools for interacting with Fabi.ai:

## Create a thread

Creates a new data analysis session (backed by a Smartbook) for SQL/Python queries. Used to start analyzing database tables, running queries, or exploring data. The thread will persist your analysis history and generated code.

**Parameters:**

* `title` (optional): Title for the analysis session

**Returns:** Thread UUID for subsequent operations

## Submit chat

Delegate a data analysis task to the Fabi autonomous agent. Takes a description of what you want in natural language - Fabi will independently handle all complexity: discovering data sources, using RAG to find relevant table/column schemas and semantics, generating SQL/Python code, validating queries with dry runs, executing them, and formatting results.

**Parameters:**

* `thread_uuid`: UUID of the thread from `create_thread`
* `message`: Natural language data analysis request (e.g., 'show top 10 customers by revenue')
* `context_cell_uuids` (optional): Previous cell UUIDs to reference in this analysis
* `context_dataframes` (optional): Variable names of dataframes to use as context

**Returns:** Request UUID and initial status

## Get chat result

Poll for the result of a long-running chat analysis request. Used by the agent when `submit_chat` returns early due to timeout (after 45 seconds). The chat continues processing in the background - call this periodically to check if results are ready.

**Parameters:**

* `request_uuid`: UUID of the chat request (returned by `submit_chat`)

**Returns:** Processing status or completed results with data preview

## Save to Smartbook

Save AI-generated cells from chat history to the Smartbook for dashboard publishing or collaboration. Used by the agent to persist, publish, or share the analysis as a dashboard. This accepts pending chat results and converts them into executable Smartbook cells. Regular analyses are already viewable in chat history and don't need saving.

**Parameters:**

* `thread_uuid`: UUID of the thread to save

**Returns:** Confirmation of saved Smartbook cells

# Usage examples

## Basic workflow

1. **Create a thread** to start a new analysis session
2. **Submit chat requests** with natural language queries
3. **Get chat results** to retrieve analysis outputs
4. **Save to Smartbook** (optional) to persist results for sharing

## Example: Analyzing sales data

```javascript theme={null}
// 1. Create a new thread
const thread = await mcp.callTool('fabi', 'create_thread', {
  title: 'Sales Analysis Q4 2024'
});

// 2. Submit an analysis request
const request = await mcp.callTool('fabi', 'submit_chat', {
  thread_uuid: thread.uuid,
  message: 'Show top 10 customers by revenue in Q4 2024'
});

// 3. Get the results
const results = await mcp.callTool('fabi', 'get_chat_result', {
  request_uuid: request.uuid
});

// 4. Save to Smartbook for sharing
await mcp.callTool('fabi', 'save_to_smartbook', {
  thread_uuid: thread.uuid
});
```

# Troubleshooting

* First try using the AI Analyst Agent in the Fabi UI to ensure it works as expected. If it does then
* If using token-based authentication, make sure you're using a valid token
* If using a local agent, restart the agent after configuring the tools

# Best practices

## Token security

* Store MCP tokens securely and never commit them to version control
* Use environment variables or secure secret management
* Rotate tokens regularly for enhanced security
* Each token should only be used by one application or user

## Error handling

* Implement retry logic for `get_chat_result` when status is "processing"
* Handle timeout scenarios gracefully
* Validate thread UUIDs before making subsequent calls

## Performance

* Use `context_cell_uuids` and `context_dataframes` to build on previous analyses
* Only call `save_to_smartbook` when you need to persist results
* Batch related queries in the same thread for better context


# Personal AI configuration
Source: https://docs.fabi.ai/advanced_features_and_dev_tools/personal_ai_configuration

Configure your AI to fit your unique needs.

# Overview

Fabi.ai allows you to configure your personal AI settings to better suit your individual needs and workflow preferences. These configurations empower you to tailor the AI's behavior, memory, model, and interaction style, making your data analysis experience more efficient and personalized.

# Configuration settings

To access these settings, click **AI Settings** from the Analyst Agent interface in any Smartbook.

<Frame>
  <img alt="AI Settings" />
</Frame>

## Longer memory

Enable longer memory to allow the AI to remember more of your conversation history. This feature is particularly useful for longer threads and complex analyses where context from earlier interactions is crucial for the AI to provide relevant suggestions and insights.

## Default AI model

Select your preferred default AI model for all interactions. Fabi.ai supports various models, and you can choose the one that best fits your requirements for speed, accuracy, or specific capabilities.

## AI action mode

Choose how the AI applies its suggestions:

* **Automatic**: The AI automatically applies its suggestions, streamlining your workflow. This mode is ideal for confident users who trust the AI's recommendations.
* **Manual**: The AI generates suggestions, but you must explicitly accept them for the changes to be applied. This mode provides more control and is suitable for users who prefer to review and approve each AI-generated action.

## Auto-run code

Configure whether the AI automatically runs the code it generates:

* Enable this setting for quick execution of AI-generated queries and scripts.
* Disable this setting if you are working on queries or scripts that can be expensive or time-consuming to run. When disabled, the AI will generate the code but will not attempt to run it until you accept it.

## Dry-run timeout

Set the maximum duration for queries or code to run before the AI automatically times out. This prevents excessively long-running operations from consuming resources or blocking your workflow.

## Custom instructions

Provide custom instructions or a custom prompt to guide the AI's behavior and responses. You can tell the AI your preferences for various aspects, including:

* **Preferred colors or chart types**: Guide the AI to use specific visual styles for your data visualizations.
* **Response style**: Instruct the AI on how it should respond, such as being concise, detailed, formal, or informal.
* **Specific analysis techniques**: Direct the AI to use particular methods or approaches for data analysis.

# Best practices

* **Experiment with settings**: Try different configurations to find what works best for your workflow.
* **Use custom instructions**: Leverage custom instructions to fine-tune the AI's responses and behavior.
* **Adjust memory for complexity**: For complex, multi-step analyses, enable longer memory to ensure the AI maintains full context.


# Secret manager
Source: https://docs.fabi.ai/advanced_features_and_dev_tools/secret_manager

Storing and managing sensitive secrets and keys in Fabi.ai.

# Overview

Data privacy and security starts with safekeeping of sensitive secrets and keys. Whether you're using API keys or tokens, handling these properly is critical.
Our vault ensures that your keys stay private to you and don't get shared with anyone else.

# Storing keys and secrets

<Warning>
  **Important**: As of May 2025, secrets are available to all Builders in your organization.
</Warning>

Simply navigate to **Settings** > **Secrets**.

To save your first secret, click on **+ Add Secret**.

Then:

1. Under **Name**, put in the name you want to use for your secret (eg. `SLACK_TOKEN`)
2. Optionally include a description under **Description**
3. Copy/paste your secret under **Secret** then click **Add Secret**

<Frame>
  <img alt="adding_secret" />
</Frame>

# Using secrets

Once you've saved a key or secret, to use it, you can reference it in any cell following this convention: `fabi.secret.MY_SECRET`.

Here's an example using a secret to store a key for the Polygon.io API:

```python theme={null}
def get_stock(api_key):
    url = f"https://api.polygon.io/v2/aggs/ticker/AAPL/range/1/day/2025-04-01/2025-05-15?apiKey={api_key}&sort=asc"
    data = requests.get(url).json().get('results', [])
    df = pd.DataFrame(data)
    if not df.empty:
        df['date'] = pd.to_datetime(df['t'], unit='ms')
        df = df[['date', 'c']]
        df.columns = ['date', 'price']
    return df

# Using the existing API key
api_key = fabi.secret.POLYGON_KEY
stock = get_stock(stock)
display(stock)
```


# Git version control
Source: https://docs.fabi.ai/advanced_features_and_dev_tools/version_control

Save your code and collaborate with your peers

# Overview

Version control is critical when working with complex analyses and workflows, especially when collaborating with your peers. Fabi offers version control connectors to help you save, share and update your code in just a few clicks.

# Connecting your GitHub account

<Note>
  We currently offer a GitHub integration. If you would like us to integrate another version control platform, please reach out to [support@fabi.ai](mailto:support@fabi.ai).
</Note>

From any Smartbook or workflow, click on the overflow menu in the header, and select `Repository Sync`

<Frame>
  <img alt="repository_sync" />
</Frame>

You'll be prompted to authorize GitHub. Once completed, you'll be ready to sync your Smartbook with GitHub.

<Frame>
  <img alt="authorizing_github" />
</Frame>

# Pushing your Smartbooks and workflows to GitHub

## Committing changes

Once you've connect Fabi to GitHub, selecting `Repository Sync` will open up a modal. You'll be prompted to provide:

* Repository name
* Branch (you can also create a new branch from here)
* Path prefix

<Frame>
  <img alt="configure_repo_sync" />
</Frame>

The Smartbook will be pushed to GitHub as a YAML file in a folder marked by the unique Smartbook ID. You can think of Smartbooks as projects, these may contain more than just the single main file.

## Automatic commits

If you're publishing your Smartbook or workflow, you can configure your settings to automatically commit updates on publish. This is a convenient feature if you're quickly iterating on a data app or workflow and want to keep the source code up to date.

<Frame>
  <img alt="automatic_commits" />
</Frame>

## Pulling changes

To pull data from your repository, simply specify the repositoy, branch and prefix that you want to pull from. In most cases, if you've pushed your code from the Smartbook, most of this information should already be populated.

<Frame>
  <img alt="pull_from_version_control" />
</Frame>


# AI Tips
Source: https://docs.fabi.ai/analysis_and_reporting/ai_tips

Quick tips to get the most out of Fabi's AI data analyst and conversational BI features.

A large part of unlocking massive productivity gains with Fabi.ai is leveraging the AI. Here are a few quick tips to make sure you get the most out of our AI.

<Frame>
  <iframe title="Publish Fabi Reports" />
</Frame>

# Tagging elements

The AI will know what code or cell you're talking about based on what you've been working on and what code you're currently looking at, but sometimes you want to be more specific. You can tag elements and cells in this situation.

> Update `@orders_analysis` to only consider data from the past 30 days

<Frame>
  <img alt="Description" />
</Frame>

To get the most ouf of the tagging functionality, consider renaming your cells to make it easier to track.

# Mentioning DataFrames

The AI will do a remarkable job at figuring out what data you're referring to, but sometimes when you're doing long, complex exploratory data analysis, you may have a lot of variables and dataframes that look similar. In that case, you can tell the AI which dataframe to use specifically.

> Please use `companies_cleaned` to calculate the average employee count per company

# Auto-accept vs Manual Mode

When you ask the Fabi Analyst Agent a question, if it produces code and an output, you'll have the option of adding the code block to the Smartbook to save it.
You can choose if you want to manually or automatically accept AI suggestions.

<Frame>
  <img alt="auto_accept_mode" />
</Frame>

Note that has a safety net, you'll always be able to revert any changes made by the AI. Whether you're in auto-accept or manual mode, whenever the AI applies changes to the Smartbook, a `Revert` button will appear in the chat history at the point where the suggestion was accepted. Clicking that button will revert the Smartbook back to the state it was in prior to the AI changes.

<Frame>
  <img alt="revert_ai_changes" />
</Frame>

# Starting a new thread

Sometimes in the middle of an analysis, it's good to start with a blank slate when you want to reset or approach a new topic.

By selecting `Start New Thread`, you can archive your existing conversation, and remove the previous prompts and output from the Analyst Agent's memory.

<Frame>
  <img alt="start_new_thread" />
</Frame>

# Selecting your AI model

Fabi offers access to all the best LLM models on the market. The list is continuously updated as new models are released, and you can generally expect the latest models from OpenAI, Anthropic and Google Gemini.

<Frame>
  <img alt="model_selector" />
</Frame>

<Note>
  Organizations on our Enterprise plan have the option of limiting the model selection to only providers pre-approved by their organization. For more information, contact [sales@fabi.ai](mailto:sales@fabi.ai).
</Note>


# Analyst Agent
Source: https://docs.fabi.ai/analysis_and_reporting/analyst_agent

Your AI-powered data analyst that understands all your data and helps you build analyses faster.

Analyst Agent is your AI-powered data analyst that lives alongside your work in Fabi. It can talk to all your connected data sources, write SQL and Python code, create visualizations, and help you build analyses—all through natural language conversation.

<Frame>
  <img alt="Analyst Agent chat interface" />
</Frame>

# Analyst Agent in Smartbooks

When you're working in a Smartbook, Analyst Agent appears in the right-hand panel as your AI-powered data analyst. It has access to all your connected data sources and can help you build analyses faster by generating code, creating visualizations, and suggesting changes to your Smartbook.

## How it works

Analyst Agent is designed to accelerate your data analysis workflow. Simply ask questions in plain English, and the AI will:

* **Query all your data sources**: Analyst Agent has access to all your connected databases, warehouses, and uploaded files
* **Generate SQL or Python code**: Automatically writes optimized queries and analysis code based on your request
* **Create visualizations**: Generates charts, tables, and other AI data visualizations to help you understand your data
* **Suggest changes to your Smartbook**: Proposes adding new cells, updating existing code, or creating new data artifacts

The AI understands your data schema, relationships between tables, and the context of your existing analysis—making it feel like working with an expert data analyst who knows your entire data landscape.

## Asking questions

Analyst Agent brings **conversational BI** to your data—simply type your question or request in natural language:

* "What are our top 10 customers by revenue this quarter?"
* "Create a cohort analysis showing user retention over the last 6 months"
* "Show me a breakdown of sales by region and product category"
* "Build a funnel chart showing conversion from signup to purchase"

<Tip>
  Use the @ symbol to reference specific data elements in your questions. For example: "Use @sales\_data to calculate monthly growth rate"
</Tip>

## Reviewing and saving suggestions

When Analyst Agent responds, you'll see:

1. **The answer or visualization** - Charts, tables, or insights based on your question
2. **The underlying code** - SQL or Python that generated the result
3. **Save option** - Add the result to your Smartbook with one click

<Frame>
  <img alt="Save AI suggestions to Smartbook" />
</Frame>

You can:

* **Save** the suggestion to add it as a new cell in your Smartbook
* **Modify** the code before saving if you want to adjust the approach
* **Ask follow-ups** to refine the analysis
* **Revert** any saved changes if you change your mind

## Configuring Analyst Agent

You can customize how Analyst Agent behaves to match your team's workflow and requirements.

To configure the AI:

1. Open up any Smartbook
2. Click on "AI Settings" above the AI chat input
3. Adjust settings like model selection, behavior, and any personal preferences

For detailed configuration options, see our [Personal AI Configuration](/advanced_features_and_dev_tools/personal_ai_configuration) guide.

***

# Embed Analyst Agent in dashboards and data apps

Beyond helping you build analyses, you can also embed Analyst Agent directly into published dashboards and data apps to provide [self-service analytics](https://www.fabi.ai/) to your stakeholders.

<Frame>
  <iframe title="Analyst Agent in Dashboards" />
</Frame>

## How embedded Analyst Agent works

When you publish a dashboard with Analyst Agent enabled, your stakeholders can ask questions about the data in that specific dashboard—without needing to write SQL or Python themselves.

Key characteristics of embedded Analyst Agent:

* **Works with curated data**: The AI only accesses the specific DataFrames you've included in the dashboard
* **Stays in scope**: Won't answer questions about data it doesn't have access to
* **Always uses fresh data**: If the dashboard is scheduled to refresh, the AI uses the latest data
* **Maintains governance**: You control exactly what data the AI can access

This modular approach makes it safer and easier to provide AI-powered analytics to non-technical stakeholders.

## Setting up embedded Analyst Agent

When building a dashboard:

1. Go to **Dashboard Builder** in the top navigation
2. [Configure your dashboard](/analysis_and_reporting/reporting_and_collaboration) with the visualizations you want to share
3. In the right-hand configuration panel, select which DataFrames the embedded AI should access
4. Add clear labels and descriptions for each DataFrame—these help the AI understand the data and are shown to users
5. [Schedule updates](/analysis_and_reporting/schedule_reports_and_workflows) if needed
6. Publish your dashboard

<Frame>
  <img alt="Configuring Analyst Agent" />
</Frame>

## Best practices for embedded AI

To maximize accuracy when embedding Analyst Agent in dashboards:

* **Don't aggregate unnecessarily**: Query data at the right level of granularity for the questions users might ask
* **Select relevant fields only**: Avoid `SELECT *` - only include columns the AI needs
* **Clean your data**: Filter out bad records, null values, or outliers
* **Use clear naming**: Rename fields to be descriptive (e.g., `amount` → `opportunity_amount_usd`)
* **Add detailed descriptions**: The DataFrame descriptions guide both the AI and your users

## Use cases for embedded Analyst Agent

Create specialized agents for different teams:

* **Marketing agent**: Access only to campaign performance and attribution data
* **Product agent**: Limited to product usage, feature adoption, and engagement metrics
* **Sales performance dashboard**: Tracks pipeline, opportunities, and revenue data to give sales teams real-time visibility
* **Customer success agent**: Scoped to account health, support tickets, and NPS data

This approach makes AI-powered analytics faster, safer, and more focused than trying to build one agent that answers every business question.

***

# FAQ

<AccordionGroup>
  <Accordion title="Can I revert changes made by Analyst Agent?">
    Yes! Every change suggested by Analyst Agent can be reverted at any point. You have full version control over your Smartbook.
  </Accordion>

  <Accordion title="What data can Analyst Agent access?">
    In Smartbooks, Analyst Agent can access all your connected data sources. In published dashboards, it only accesses the specific DataFrames you've configured for that dashboard.
  </Accordion>

  <Accordion title="How does embedded Analyst Agent stay in sync with source data?">
    Embedded Analyst Agent always uses the latest data available in the dashboard. If you've scheduled the dashboard to refresh, or if users update filters/inputs, the AI uses the current data.
  </Accordion>

  <Accordion title="What happens if someone asks a question the AI can't answer?">
    Analyst Agent will only answer questions using data it has access to. If it doesn't have the necessary data, it will let the user know rather than guessing or making up information.
  </Accordion>

  <Accordion title="Can I see the code behind Analyst Agent's answers?">
    Yes! Every response includes the SQL or Python code that generated it. You can review, modify, or learn from the code.
  </Accordion>

  <Accordion title="What AI model powers Analyst Agent?">
    This depends on your organization's configuration. You may be using OpenAI, Anthropic, or a private LLM if you're an enterprise customer. The active model is displayed in the AI chat interface.
  </Accordion>

  <Accordion title="Can I customize Analyst Agent's behavior?">
    Yes! You can configure various aspects of the AI through your workspace settings. See our [Personal AI Configuration](/advanced_features_and_dev_tools/personal_ai_configuration) guide for details.
  </Accordion>

  <Accordion title="How does Fabi compare to traditional BI tools?">
    Traditional BI tools require you to manually build queries and reports. Fabi brings conversational BI and generative BI capabilities to your data—you simply ask questions in plain English and the AI handles the analysis, code generation, and visualization. This makes Fabi a true self-service analytics platform where both technical and non-technical users can get answers from their data quickly.
  </Accordion>
</AccordionGroup>


# Exporting Data
Source: https://docs.fabi.ai/analysis_and_reporting/exporting_data

Export your tabular data as CSV files or push to Google Sheets

# Overview

Fabi.ai provides multiple ways to export your data for sharing, analysis, or integration with other tools. Whether you need a simple CSV download or want to push data directly to Google Sheets, we've got you covered.

# Exporting as CSV

You can export any tabular data from your Smartbooks as a CSV file. This is perfect for:

* Sharing data with stakeholders who prefer spreadsheet formats
* Importing data into other analysis tools
* Creating backups of your analysis results
* Providing data for external reporting systems

## How to export

1. **From SQL results**: After running a SQL query, click the download icon in the results panel
2. **From Python DataFrames**: Use the export functionality in any DataFrame output
3. **From Dashboards & data apps**: Export data directly from published dashboards

<Frame>
  <img alt="Export CSV functionality" />
</Frame>

The exported CSV file will include all the data from your query or DataFrame, maintaining the column structure and data types.

# Pushing to Google Sheets

For more advanced data sharing and collaboration, you can push your data directly to Google Sheets. This is especially useful for:

* Regular reporting to stakeholders
* Creating executive dashboards
* Automating data updates in existing workflows
* Sharing data with non-technical team members

See our dedicated [Push to Google Sheets](/workflow_automation/push_to_google_sheets) documentation for step-by-step setup and best practices.


# Filters and inputs
Source: https://docs.fabi.ai/analysis_and_reporting/filters_and_inputs

Create interactive filters and inputs for self-service analytics—let stakeholders explore data and run ad hoc analysis on their own.

<Frame>
  <iframe title="Publish Fabi Reports" />
</Frame>

# Creating filters & inputs

Once you’ve built some insights that you’d like to share, the next step is to make these interactive so your stakeholders can explore the insights on their own. This is the foundation of **self-service analytics**—giving stakeholders the ability to do **ad hoc analysis** without needing to ask a data analyst every time.

To do this, we’ll need to create filters and inputs.

You can create the following types of filters and inputs:

* Date and date ranges
* Dropdown lists
* Numbers
* Boolean (True/False)
* Text

## Filter and input types and variables

Fabi.ai offers a wide variety of configuration options so that you can create virtually any type of dashboard or data app.

* Dates
  * You can can create a single date picker or a date range
* Dropdown lists
  * You can choose if you want the values in the list to be manually created or dynamically generated from a list of distinct values in a table (DataFrame) filtered\_customers
  * You can choose if you want to let the user select a single value at a time or multiple values. Note that which one you select requires a different treatment in SQL and Python. Single values are treated as strings whereas multi-select values are treated as lists
* Numbers
  * You can create a single number input or a range selector
* Boolean
* Text

<Frame>
  <img alt="Description" />
</Frame>

## Creating filters and inputs in SQL

To add a filter or input to a SQL query, find the variable that you want to parameterize, and replace it with `{{your_variable_name}}`.

For example:

```sql theme={null}
select * 
from customers
where age > {{customer_age}}
```

Next, above the SQL cell, select **Insert a new cell** then **Filters & Inputs**. Select the type and enter the required information. Once you’re done, press **Submit**.

Step 1: Create a variable

<Frame>
  <img alt="Description" />
</Frame>

Step 2: Create a filter or input

<Frame>
  <img alt="Description" />
</Frame>

Step 3: Configure the filter or input

<Frame>
  <img alt="Description" />
</Frame>

Note: You can also insert these parameters in text cells

```
This dashboard shows a list of customers where age > {{customer_age}}.
```

## Creating filters and inputs in Python

You can create filters and inputs in Python cells the exact same way that you would for SQL, except that you can’t just use the variable directly, without the `{{}}`.

For example:

```python theme={null}
filtered_customers = customers[customers['age'] > customer_age]
```


# Publishing Dashboards & data apps
Source: https://docs.fabi.ai/analysis_and_reporting/reporting_and_collaboration

Build and publish business intelligence dashboards with Fabi's AI dashboard builder. Share KPI dashboards, sales dashboards, and more in minutes.

# Building Dashboards & data apps

Once you’ve found the insights you’d like to share and added filters and inputs, it’s time to package this up into a polished **business intelligence dashboard** and share it with your stakeholders. Whether you’re building a KPI dashboard, an analytics dashboard for a specific team, or an executive overview, [Fabi’s AI dashboard builder](https://www.fabi.ai/) turns your analysis into a shareable dashboard in minutes.

<Frame>
  <iframe title="Publish Fabi Reports" />
</Frame>

## Configuring your dashboard layout

When publishing a dashboard based on your analysis, you likely want to change the layout a bit to tell a better story. To building your dashboard by clicking **Report** on the top menu bar from your Smartbook:

<Frame>
  <img alt="Description" />
</Frame>

In this view, you can do a few things:

1. Select which elements you would like to display in your published dashboard
2. Re-order and resize elements
3. Schedule your dashboard to run on a given cadence

<Note>
  **Important**: The order of the cells in the Smartbook matters, but in the dashboard, you can reorder cells however you want. [Fabi.ai](https://www.fabi.ai/) tracks dependencies between cells, which gives you the freedom to craft your dashboard in whichever way will resonate the most with your stakeholders.
</Note>

<Frame>
  <img alt="Description" />
</Frame>

## Publishing & sharing a dashboard

When your dashboard is ready to be published, click **Publish** and [Fabi.ai](https://www.fabi.ai/) will open up a new tab with your published dashboard.

<Frame>
  <img alt="Description" />
</Frame>

To share this dashboard, copy/paste the URL and share it with your colleagues, or if they're already [Fabi.ai](https://www.fabi.ai/) users, tag them in a comment.

## Scheduling dashboards

If you would like to schedule this Dashboard & data app to refresh on a specific cadence, in the Publish view, click "Disabled" next to Schedule in the right hand panel.

Select the time and cadence at which you would like to refresh the data and hit Submit.

For more information on how to schedule updates, check out [this](https://docs.fabi.ai/analysis_and_reporting/schedule_reports_and_workflows) page.

# Dashboards & data apps FAQ

<AccordionGroup>
  <Accordion title="Can I share Dashboards & data apps with my team?">
    Yes! Once you've published a dashboard, simply share the URL with anyone in your organization.
  </Accordion>

  <Accordion title="Can I scheduled Dashboards & data apps to refresh?">
    Yes, during the configuration step, [you can choose how frequently you want to refresh your data](/analysis_and_reporting/schedule_reports_and_workflows).
  </Accordion>

  <Accordion title="How can I embed the Fabi.ai AI agent in my dashboards?">
    Analyst Agent will automatically be embedded in your dashboards to help you handle follow-up requests from your stakeholders. You can configure the data artifacts that you want to make available to [Analyst Agent](/analysis_and_reporting/analyst_agent).
  </Accordion>

  <Accordion title="What types of dashboards can I build with Fabi?">
    Almost any kind. Fabi is used to build KPI dashboards, sales dashboards, marketing dashboards, CRM dashboards, analytics dashboards, and more. Because you can connect any data source and use AI to analyze it, you can build a business intelligence dashboard for virtually any team or use case.
  </Accordion>

  <Accordion title="Does the order of my widgets matter for code execution?">
    Part of the beauty of Dashboards & data apps is that you can fully customize the layout of your dashboards regardless of execution order. We use a sophisticated dependency tracker to maintain proper and optimal execution. This is also why Fabi.ai provides world-class latency in dashboards.
  </Accordion>
</AccordionGroup>


# Scheduling updates
Source: https://docs.fabi.ai/analysis_and_reporting/schedule_reports_and_workflows

Schedule dashboards, Slack or Google Sheet pushes.

# Scheduling data refreshes

Once you've completed your analysis or built your data workflow to push updates to Slack or [Google Sheets](https://docs.fabi.ai/workflow_automation/google_sheets_integration), you can schedule your dashboard to refresh at a cadence of your chosing.

When publishing a dashboard, simply select the **Schedule** option.

<Frame>
  <img alt="Description" />
</Frame>

## Custom schedules

If you have very particular or unique scheduling cadence needs, you can let the AI handle that for you!

For example, if you would like to schedule your data to be refreshed every 30 minutes on weekdays from 9 to 6, simply ask the AI using the **Custom scheduling** functionality.

Simply write in plain text what schedule you would like to set and the AI will generate the custom cron expression.

<Frame>
  <img alt="Description" />
</Frame>


# Smartbooks
Source: https://docs.fabi.ai/analysis_and_reporting/smartbooks

Smartbooks are AI-powered notebooks for Python data analysis, SQL querying, and building dashboards—a powerful Google Colab alternative built for enterprise teams.

# Introduction to AI notebooks: Smartbooks

Smartbooks are the next generation AI notebooks—and a powerful [Google Colab alternative](https://www.fabi.ai/)—designed with an AI-first approach for enterprise teams. They're designed to address the core issues with traditional notebooks while being accessible to everyone from professional data scientists to product managers:

* **State management**: With a carefully designed dependency tracking engine and intelligent caching system, you don't run the risk of running into reproducibility issues caused by variable states
* **Performance**: Smartbooks are incredibly performant and scalable. Designed using new technologies like DuckDB, polars and Apache Arrow, Smartbooks are built for the enterprise
* **Collaborative**: With Smartbooks, collaboration can happen both between data practitioners working on Smartbooks, but also between the data practitioner and their stakeholder with Dashboards & data apps and workflow publishing
* **AI-powered**: Most importantly, in the age of AI, Smartbooks are designed with AI natively built in. Your AI analyst which lives in every Smartbook can read, edit and run the Smartbook just like you would. It's your perfect companion to help accelerate your workflow and let you focus on the things that matter

# Core concepts

Smartbooks are inherently intuitive and easy to get started with. Here are just a few core concepts to know as you get started:

## Cells

Cells are simply blocks of code or purpose-built blocks. The two core cells are:

1. **SQL cells**: A SQL cell is where you can query data from any of your connected data sources. Each SQL cell will produce a single table in the form of a DataFrame
2. **Python cells**: A Python cell is where you can write Python scripts

<Frame>
  <img alt="SQL cell" />
</Frame>

## DataFrames and chaining cells

You can chain multiple cells together by leveraging DataFrames. For example, if you have a SQL cell that produces `dataframe1`, you can leverage that DataFrame is SQL or Python cell further down in the Smartbook.

**SQL cell chaining**

```sql theme={null}
select * from dataframe1
```

Notice how `dataframe1` is not a table from your data source.

<Note>
  **Pro tip**: Any cell that does not query your data warehouse will used cached data. This means that once you've pulled your data into Fabi.ai we won't requery your data source until you explicitly rerun a SQL query. This helps both decrease latency and reduce warehouse compute costs.
</Note>

**Using a SQL cell output in a Python cell**

```python theme={null}
df_copy = dataframe1.copy()
display(df_copy)
```

This very simplistic Python snippet shows you how you can use `dataframe1` produced by another cell.

This is powerful, because you (or the Analyst Agent) can interweave between different languages and cells to use the best tool for the job!

## Running your Smartbook

Each cell has a `Run` button which by default will run the upstream cells that are stale and downstream cells. Ensures that you don't run more code than needed, helping improve latency, while avoiding any variable state issues that exist in traditional Jupyter notebooks.

You can select the dropdown on the `Run` button to see different options.

If you would like to run the entire Smartbook regardless of staleness, you have that option in the overflow menu in the Smartbook header menu.

<Frame>
  <img alt="Run entire Smartbook" />
</Frame>

Here are some keyboard shortcuts you may find helpful:

* **Cmd + Enter** Run current cell and stale upstream cells and all downstream dependent cells
* **Shift + Enter**: Only run the current cell

# Connecting your data

To maximize the use of your Smartbook, you'll want to [connect to all your data sources](/getting_started/connect_data_sources). You can even query different data sources and merge DataFrames in a Smartbook!

Note that in SQL cells you can specify which source you want to query. The AI will generally try and guess the source based on the table names and other information, but sometimes you'll need to override it.

# Leveraging our AI data analyst

The power of Smartbooks not only comes from the feature richness and underlying design, but also from the integrate AI data analyst assistant.

The AI data analysis agent has the full context of your analysis and can help cut down the time to build dashboards and workflows by up to 90% thanks to some of the following features:

* **Code generation** The AI analyst agent can generate SQL or Python from scratch or edit existing code
* **Debugging** With the `Autocorrect` feature which appears when the code outputs an error, the AI can troubleshoot issues, including auto installing packages
* **Schema exploration** If you're not sure which tables or fields to query you can simply ask the AI
* **Insight generation** The AI can also invoke an LLM to inspect results and outputs from your code to provide an interpretation of the results

Check out our [AI Tips](/analysis_and_reporting/ai_tips) guide for more information.

# Publishing, scheduling and sharing dashboards and workflows

When you're ready to share your analysis or workflow with your team (or the world!), you can turn your Python data analysis or SQL work into a polished, auto-refreshing Python dashboard in just a few clicks.

In the [dashboard builder](https://docs.fabi.ai/analysis_and_reporting/reporting_and_collaboration) you can re-arrange and remove widgets and [schedule your dashboard or workflow to refresh](/analysis_and_reporting/schedule_reports_and_workflows).

<Note>
  **Pro tip**: You can create filters and inputs that can be leveraged both in Smartbooks and in the dashboards or workflows that you publish. Check out our [Filters and inputs](/analysis_and_reporting/filters_and_inputs) page for more details.
</Note>

# Smartbooks FAQ

<AccordionGroup>
  <Accordion title="How are Smartbooks different from traditional Jupyter notebooks?">
    Smartbooks, otherwise known as AI notebooks, are significantly more advanced than traditional notebooks like Jupyter or Google Colab in a few key ways: You can use a mix of SQL, Python, AI and no-code to conduct your analysis, you can convert your Smartbooks to workflows and dashboards that can refresh on schedule, and they're designed for the enterprise by being scalable and highly performant.
  </Accordion>

  <Accordion title="How are cell dependencies tracked?">
    Fabi.ai uses a proprietary dependency tracker to track which variables are leveraged in various cells to create a dependency map.
  </Accordion>

  <Accordion title="Can I install Python packages in Smartbooks?">
    You sure can. Simply create a Python and `pip install`, or better yet, ask the AI to do it for you! Installed packages are then tracked for that specific Smartbook and included in the published dashboards and workflows.
  </Accordion>

  <Accordion title="Can I push data to Slack, email and other destinations from a Smartbook?">
    This is one of the primary use cases our customers use Smartbooks for! Simply build your analysis, and use a dedicated cell to push to other systems or ask the AI to write some code to do it for you.
  </Accordion>

  <Accordion title="Can I build dashboards and data apps off a Smartbook?">
    Yes, converting an analysis you've done to an interactive dashboard is extremely easy. You can do this in just a few clicks. Check out our [Publishing Dashboards & data apps](/analysis_and_reporting/reporting_and_collaboration) page.
  </Accordion>

  <Accordion title="Can I schedule Smartbooks to refresh on schedule?">
    Yes! Not only can you turn your AI notebook into a dashboard or workflow in minutes, you can also configure them to refresh on any schedule you'd like.
  </Accordion>

  <Accordion title="Are Smartbooks secure?">
    Absolutely. We're SOC2 Type 2 compliant and have security and privacy built-in. We have more information in our [Security Hub](https://www.fabi.ai/security).
  </Accordion>
</AccordionGroup>


# Uploading files
Source: https://docs.fabi.ai/analysis_and_reporting/uploading_files

You can analyze data from Excel, CSV or even Google Sheets.

# Uploading a file

Working with files is common to all ad hoc and exploratory data analysis. To get started, simply click on the **paper clip icon** from the Analyst Agent chat box or **Upload a file** from an empty Smartbook.

<Frame>
  <img alt="Description" />
</Frame>

Once uploaded, your data will be available to Analyst Agent and you can start asking questions.

You can always see which files you've uploaded from the **Data source** pane on the left hand side.

<Frame>
  <img alt="Description" />
</Frame>

# Supported file formats

We support nearly any format you can imagine. The most commonly used file formats that we support:

* CSV or TSV
* Excel
* PDF
* And many more

We're continuously adding new formats and functionality, so please feel free to reach out to [support@fabi.ai](mailto:support@fabi.ai) if you have any particular requests!

# Connecting Google Sheets

If you would rather connect directly to Google Sheets, check out our [Google Sheet connector guide](/workflow_automation/pull_from_google_sheets).


# Real-time collaboration
Source: https://docs.fabi.ai/collaboration_and_organization/collaboration_commenting

Real-time team collaboration and commenting

# Real-time collaboration

A large part of the magic of Fabi is the ability to do **collaborative analytics** in real time—whether you're working together on a Smartbook or sharing insights through a published dashboard.

After [sharing](./sharing) a Smartbook with a colleague, they will be able to make edits if you've given them edit rights. When two or more individuals work in the same Smartbook at the same time, you will be informed if you're working on a version that's behind the latest version and you will be prompted to refresh you browser.

# Commenting

[Fabi.ai](https://fabi.ai) brings the collaboration right to your insights. You can comment and tag coworkers in Smartbooks or Dashboards & data apps. Comments in Smartbook and dashboards are unique to each. This way, you can discuss code and findings with other technical stakeholders in your Smartbook and discuss insights with your stakeholders in Dashboards & data apps.

Tagged users will receive an email with a link to the relevant Smartbook and Dashboard or data app.

<Frame>
  <img alt="Description" />
</Frame>


# Organizing your workspace
Source: https://docs.fabi.ai/collaboration_and_organization/folders_and_workspaces

Organize your workspace with folders

# Workspace structure

Your workspace is automatically organized into four categories in the left hand navigation menu:

1. **Favorites** Specific Smartbooks, dashboards and workflows that you've starred
2. **Organization** Work shared with the entire organization
3. **Shared** Work shared with a specific list of individuals
4. **Private** Work that only you have access to

<Frame>
  <img alt="Description" />
</Frame>

## Organizing your workspace

To better organize and strucutre your work, you can create folders and sub-folders in your private workspace.

Simply click the **+** button by `Private` and then **Create Folder**

<Frame>
  <img alt="Description" />
</Frame>

You can just as easily rename or delete folders, and move your work from one folder to the next.


# Sharing and access control
Source: https://docs.fabi.ai/collaboration_and_organization/sharing

Sharing your work with coworkers

# Granting access

You can share any of your work in Fabi with your coworkers, whether it's an ad hoc analysis in a Smartbook or a polished dashboard.

On any page, click the `Share` button in the top menu and select who you would like to share it with. You have two options:

1. **Individual user sharing**: You can choose specific individuals to share your work with
2. **Org-level sharing**: You can share your work with everyone in your organization

For each of these you can choose if the individuals you're sharing your work with have read-only access to edit access.

As the owner of a Smartbook, dashboard or workflow, you can revoke access at any time.

<Frame>
  <img alt="Description" />
</Frame>


# Quick Start
Source: https://docs.fabi.ai/getting_started/ai_powered_data_analysis

Get started with Fabi.ai in minutes. Learn how to upload data, ask questions, and create your first dashboard.

Welcome to Fabi.ai! This guide will walk you through the essentials to get you analyzing data and building dashboards in just a few minutes.

## Step 1: Create your account

First, create your Fabi.ai account:

1. Navigate to [https://app.fabi.ai/](https://app.fabi.ai/)
2. Click **Sign in with Google** and log in

<Tip>
  **Pro tip:** Use your corporate email address to unlock collaboration features and work seamlessly with your team.
</Tip>

## Step 2: Get your data into Fabi

The fastest way to start analyzing is to either **upload a file** or **connect a Google Sheet**.

### Upload a file

Fabi.ai supports CSV, Excel, Parquet, and JSON files. Simply:

1. From the landing page, click **Start analyzing a file**
2. Select your file and upload it

Fabi.ai stores your data in DuckDB, so you can analyze large files without performance issues.

<Frame>
  <img alt="Upload a file interface" />
</Frame>

### Connect a Google Sheet

Alternatively, you can connect directly to Google Sheets:

1. Click **Connect data source**
2. Select **Google Sheets**
3. Authenticate and choose your sheet

For more data sources like databases and warehouses, check out our [Connecting data sources](connect_data_sources) page.

## Step 3: Ask the AI questions

Now comes the fun part! Using AI for data analysis with Fabi is as simple as asking a question in plain English.

<Frame>
  <img alt="AI chat interface" />
</Frame>

The AI will:

* Automatically write SQL or Python code
* Generate charts and visualizations
* Analyze trends and insights
* Handle follow-up questions

**Example questions you can ask:**

* "What are the top 10 products by revenue?"
* "Show me monthly sales trends as a line chart"
* "Which customers have the highest lifetime value?"
* "Create a breakdown of revenue by region"

<Tip>
  You can reference specific data elements using @ to tag them in your questions.
</Tip>

## Step 4: Save results to your Smartbook

When the AI generates insights you want to keep:

1. Review the AI's suggestion (table, chart, or analysis)
2. Click **Save** to add it to your Smartbook

Each saved element becomes a block in your Smartbook - think of it as your interactive analysis workspace where tables, charts, and code cells come together.

<Frame>
  <img alt="Save AI suggestions to Smartbook" />
</Frame>

## Step 5: Publish as a dashboard

Ready to share your work? Turn your Smartbook into a polished dashboard:

1. Click **Build Dashboard** in the top navigation
2. Your saved blocks are automatically formatted into a shareable dashboard
3. Customize the layout if needed
4. Share with your team or publish it

<Frame>
  <img alt="Publish dashboard" />
</Frame>

<Info>
  Dashboards can be scheduled to update automatically and shared with your team for real-time collaboration.
</Info>

## What's next?

Now that you've created your first analysis and dashboard, explore more advanced features:

<CardGroup>
  <Card title="AI tips & tricks" icon="sparkles" href="/analysis_and_reporting/ai_tips">
    Master advanced AI techniques for deeper analysis
  </Card>

  <Card title="Automate workflows" icon="diagram-project" href="/workflow_automation/workflows">
    Schedule dashboards and automate data pipelines
  </Card>

  <Card title="Connect databases" icon="database" href="connect_data_sources">
    Connect to Snowflake, BigQuery, PostgreSQL, and more
  </Card>

  <Card title="Analyst Agent" icon="robot" href="/analysis_and_reporting/analyst_agent">
    Use our embedded AI agent for advanced analysis
  </Card>
</CardGroup>


# Connecting to your data
Source: https://docs.fabi.ai/getting_started/connect_data_sources

Connect your databases, data warehouses, and SaaS tools to Fabi for AI-powered data analysis across all your sources.

# Connecting your data sources

<Tip>
  For information about our industry-leading security practices, check out our [Security hub](https://www.fabi.ai/security).
</Tip>

Fabi.ai supports three types of data connections:

1. **Application connectors** - Connect to SaaS applications like HubSpot, Google Ads, Shopify, and hundreds more
2. **Database & data warehouse connectors** - Connect to your databases like Snowflake, BigQuery, PostgreSQL, and more
3. **Google SHeets connector** - Connect your Google Sheet directly to a Fabi Smartbook

To connect a new data source, in the data panel on the left hand side of a Smartbook, click **Add Data Source** or go to the [data connector settings page](https://app.fabi.ai/settings/data-sources).

<Frame>
  <img alt="Description" />
</Frame>

## Application connectors

Fabi.ai offers hundreds of pre-built application connectors that allow you to sync data from popular SaaS platforms directly into your analysis. These connectors make it easy to bring in data from:

* **Marketing & Advertising**: Google Ads, Facebook Ads, LinkedIn Ads, HubSpot, Mailchimp, and more. Build a marketing dashboard that unifies all your campaign data in one place.
* **E-commerce**: Shopify, Stripe, WooCommerce, and more
* **Sales & CRM**: Salesforce, HubSpot CRM, Pipedrive, and more. Build sales dashboards and CRM dashboards to track pipeline and revenue in real time.
* **Analytics**: Google Analytics, Mixpanel, Segment, and more
* And many more...

**How application connectors work:**

1. Select the application you want to connect
2. Authenticate using your credentials (OAuth or API keys)
3. Fabi.ai automatically syncs your data on a regular schedule

No technical configuration required - just authenticate and start analyzing!

<Tip>
  Fabi will only get access to the data that the authenticated user has access to. Ensure that whichever user establishes the connection has access to all the data you wish to analyze.
</Tip>

<Info>
  **Application connector pricing:** \$100/month per connector, which includes 200k record updates. Additional records are prorated at \$50 per 100k. We automatically set an overage limit of \$400 per connector (configurable in your settings). If you hit that limit, we'll pause your sync and send you an email notification.

  The 100k monthly records included in the base price is usually sufficient for most connectors unless you're tracking high-volume data such as ads, product event tracking, email tracking, or IoT data.

  For any questions, contact us at [support@fabi.ai](mailto:support@fabi.ai).
</Info>

## Database & data warehouse connectors

For connecting to databases and data warehouses, you'll need to provide connection credentials and may need to configure network access.

<Frame>
  <img alt="Description" />
</Frame>

Important: You may need to authorize [Fabi.ai](https://www.fabi.ai/)'s IP addresses to have access to your database. See note below.

# Your cloud configuration (a note for your platform and IT team)

<Warning>
  Before connecting, ensure that you whitelist Fabi.ai's IP addresses in your firewall or security group settings:

  * `3.232.60.87`
  * `54.172.255.171`
</Warning>

# Database connection instructions

For help generating service user accounts and tokens for specific database integrations, check out our individual pages:

* [Snowflake](/integrations_and_connectors/snowflake)
* [Big Query](/integrations_and_connectors/bigquery)
* [PostgreSQL](/integrations_and_connectors/postgresql)
* [Redshift](/integrations_and_connectors/redshift)
* [MySQL](/integrations_and_connectors/mysql)
* [ClickHouse](/integrations_and_connectors/clickhouse)
* [MotherDuck](/integrations_and_connectors/motherduck)

For any additional help getting set up, please reach out to [support@fabi.ai](mailto:support@fabi.ai) .

# Fabi data connectors FAQ

<AccordionGroup>
  <Accordion title="Does Fabi offer help getting set up?">
    Yes, we can work with you to make sure you're set up properly. Reach out to [support@fabi.ai](mailto:support@fabi.ai) and our team will assist you with the setup process.
  </Accordion>

  <Accordion title="If I need help getting some of my data ready, can Fabi help me?">
    Yes, we offer complementary data services to help model data and prep the data. Our team can assist you in structuring your data for optimal analysis. Contact [support@fabi.ai](mailto:support@fabi.ai) to learn more.
  </Accordion>

  <Accordion title="If I don't see a connector, can Fabi add it?">
    Yes, we're constantly adding new connectors and can work with you to prioritize the ones you need. Let us know which connector you're looking for by reaching out to [support@fabi.ai](mailto:support@fabi.ai).
  </Accordion>

  <Accordion title="Can Fabi join data between two applications or sources?">
    Yes. However, you need to ensure that there's a clear ID to match on - even if it's fuzzy matching - and you may need to provide this context to the AI. Once the matching fields are identified, Fabi can seamlessly join data across different sources in your analysis.
  </Accordion>
</AccordionGroup>


# AI context & semantics
Source: https://docs.fabi.ai/integrations_and_connectors/ai_context_and_semantics

Provide AI context and semantic guidance for your data sources.

# Overview

Fabi.ai leverages AI context and semantics to enhance its understanding of your data sources. By providing additional context in plain text or markdown, you can guide the AI to interpret your data more accurately, generate more relevant insights, and streamline your data analysis workflows. These settings are applied globally for all users accessing a specific data source.

# Providing AI context

To access a data source's context, click on the overflow menu next to any source and click **Edit Semantics**

<Frame>
  <img alt="AI Semantics" />
</Frame>

## Plain text context

You can provide general context about your data source in plain text. This is useful for describing the overall purpose, key metrics, or any specific nuances of the data that the AI should be aware of.

**Examples of plain text context:**

* "This database contains sales data from our e-commerce platform, including customer information, product details, and order history. The primary key for the 'orders' table is 'order\_id'."
* "The 'transactions' table stores all financial transactions. The 'amount' column is in USD, and 'transaction\_date' is in UTC."

## Markdown context

For more structured and detailed context, you can use markdown. This allows you to include formatting, headings, lists, and code blocks to provide comprehensive guidance to the AI. Markdown is ideal for explaining complex relationships, business logic, or specific data definitions.

**Examples of markdown context:**

```markdown theme={null}
### Key performance indicators (KPIs)

*   **Revenue**: Sum of 'amount' from the 'orders' table.
*   **Customer Lifetime Value (CLV)**: Calculated as average order value multiplied by purchase frequency and average customer lifespan.

### Data quality notes

*   The 'customer_segment' column in the 'users' table may contain null values for new users.
*   The 'product_category' field should always be one of ['Electronics', 'Apparel', 'Home Goods', 'Books'].
```

# Global application

All AI context and semantic settings you configure for a data source are applied globally. This means that any user within your Fabi.ai workspace who accesses that data source will benefit from the enhanced AI understanding, ensuring consistent and accurate analysis across your team.

# Best practices

* **Be specific**: The more detailed and specific your context, the better the AI can understand and interpret your data.
* **Keep it updated**: As your data sources evolve, update the AI context to maintain accuracy.
* **Focus on business logic**: Provide context that explains the business meaning of your data, not just technical details.


# Big Query
Source: https://docs.fabi.ai/integrations_and_connectors/bigquery

Connecting Fabi.ai to your [BigQuery](https://cloud.google.com/bigquery) instance.

<Warning>
  Before connecting, ensure that you whitelist Fabi.ai's IP addresses in your firewall or security group settings:

  * `3.232.60.87`
  * `54.172.255.171`
</Warning>

# Creating a service account user

## 1. Go to the Google Cloud Console

* Open the [Google Cloud Console](https://console.cloud.google.com/).

## 2. Navigate to the "IAM & Admin" Section

1. In the navigation menu, go to **IAM & Admin** > **Service Accounts**.
   * Direct link: [Service Accounts](https://console.cloud.google.com/iam-admin/serviceaccounts)

## 3. Create a New Service Account

1. Click the **+ CREATE SERVICE ACCOUNT** button.

2. Provide the following details:
   * **Service account name**: Choose a meaningful name (e.g., `bigquery-service-account`).
   * **Service account ID**: This will auto-generate based on the name.
   * **Service account description**: Optionally, add a brief description.

3. Click **CREATE AND CONTINUE**.

## 4. Grant Permissions to the Service Account

1. In the next step, assign roles to the service account:
   * Select **BigQuery Admin** or other relevant roles, depending on your needs.
   * For detailed role descriptions, see the [BigQuery Roles documentation](https://cloud.google.com/bigquery/docs/access-control#bigquery_roles).

2. Click **CONTINUE**.

## 5. Set Up Access to the Service Account (Optional)

1. If needed, specify users or groups who can access or manage the service account.
2. Click **DONE** to complete the creation process.

## 6. Generate and Download a Key

1. In the **Service Accounts** list, locate your new service account.
2. Click the **⋮ (More Actions)** menu and select **Manage Keys**.
3. Click **ADD KEY** > **Create new key**.
4. Select the key type:
   * Choose **JSON**.
5. Click **CREATE** to download the key file.
   * Save the JSON file securely, as it contains sensitive credentials.

For more details, refer to the [Service Accounts documentation](https://cloud.google.com/iam/docs/service-accounts).

# Connecting Big Query to Fabi.ai

Once you've generated your service user credentials, follow the steps in [Connecting to Your Data](/getting_started/connect_data_sources)
<Tip>For information about our industry-leading security practices, check out our [Security hub](https://www.fabi.ai/security).</Tip>


# ClickHouse
Source: https://docs.fabi.ai/integrations_and_connectors/clickhouse

Connecting Fabi.ai to your [ClickHouse](https://clickhouse.com/) instance.

<Warning>
  Before connecting, ensure that you whitelist Fabi.ai's IP addresses in your firewall or security group settings:

  * `3.232.60.87`
  * `54.172.255.171`
</Warning>

# Obtaining connection details

Connection details for ClickHouse are readily available in the ClickHouse interface.

We recommend following the instructions available [here](https://clickhouse.com/docs/integrations/fabi.ai) in their documentation.

# Connecting ClickHouse to Fabi.ai

Once you've generated your service user credentials, follow the steps in [Connecting to Your Data](/getting_started/connect_data_sources)
<Tip>For information about our industry-leading security practices, check out our [Security hub](https://www.fabi.ai/security).</Tip>


# Databricks
Source: https://docs.fabi.ai/integrations_and_connectors/databricks

Connecting Fabi.ai to your [Databricks](https://www.databricks.com/) instance.

<Warning>
  Before connecting, ensure that you whitelist Fabi.ai's IP addresses in your firewall or security group settings:

  * `3.232.60.87`
  * `54.172.255.171`
</Warning>

# Creating a service principal for Databricks

Creating a service principal in Databricks involves setting up programmatic access for tasks like automation, integration, or API-based operations. Service principals provide secure, non-interactive authentication for applications.

In order to generate an access token for service principals, we recommend following the Databricks instructions listed [here](https://docs.databricks.com/aws/en/dev-tools/auth/pat#databricks-personal-access-tokens-for-service-principals).

# Connecting Databricks to Fabi.ai

Once you've generated your service principal credentials, follow the steps in [Connecting to Your Data](/getting_started/connect_data_sources). You'll need:

* **Server hostname**: Your Databricks workspace URL
* **HTTP path**: Found in your cluster/SQL warehouse connection details
* **Access token**: The personal access token generated above
* **Service principal ID**: The application ID of your service principal

<Tip>For information about our industry-leading security practices, check out our [Security hub](https://www.fabi.ai/security).</Tip>


# Managing data sources
Source: https://docs.fabi.ai/integrations_and_connectors/managing_data_sources

Manage your connected data sources in Fabi.ai.

# Overview

Fabi.ai provides robust tools for managing your connected data sources, allowing you to maintain accurate, up-to-date, and well-organized access to your data. Efficient data source management ensures that your AI analyses and workflows always operate with the correct information.

# Data source management actions

## Manually trigger a schema refresh

Data sources evolve, and their schemas can change over time. To ensure Fabi.ai always has the most current understanding of your data structure, you can manually trigger a schema refresh. This action forces Fabi.ai to re-inspect your data source and update its internal representation of tables, columns, and data types.

**When to refresh:**

* After adding new tables or columns to your database.
* After modifying existing table or column names or data types.
* If you notice discrepancies between your data source and what Fabi.ai is reporting.

## Rename data sources

To improve clarity and organization, you can rename your data sources within Fabi.ai. This allows you to use more explicit and user-friendly names that better reflect the purpose or content of the data source.

**Benefits of renaming:**

* **Clarity**: Make it easier for all users to understand what each data source contains.
* **Organization**: Keep your list of connected sources tidy and intuitive.
* **Consistency**: Align data source names with your internal naming conventions.

## Delete data sources

If a data source is no longer needed or is decommissioned, you can delete it from Fabi.ai. This action removes the connection and prevents any further AI analyses or workflows from accessing that source.

**Important considerations:** Ensure no critical Smartbooks or workflows are actively using the data source before deletion.

## Edit configuration

Modify the connection parameters and settings for an existing data source. This is useful if your database credentials change, the host address is updated, or other connection-related details need adjustment.

**Configurable settings may include:**

* Database credentials (username, password)
* Host, port, and database name
* SSL/TLS settings
* IP whitelist configuration


# MotherDuck
Source: https://docs.fabi.ai/integrations_and_connectors/motherduck

Connecting Fabi.ai to your [MotherDuck](https://motherduck.com/) instance.

<Warning>
  Before connecting, ensure that you whitelist Fabi.ai's IP addresses in your firewall or security group settings:

  * `3.232.60.87`
  * `54.172.255.171`
</Warning>

# Generating a service token

1. Log in to the [MotherDuck web console](https://app.motherduck.com/) using your regular user credentials
2. Go to the *Settings* menu under your org name in the top left hand corner
3. Under the *General* tab click *Create token* and fill out the form

# Connecting MotherDuck to Fabi.ai

Once you've generated your service token, follow the steps in [Connecting to Your Data](/getting_started/connect_data_sources)

<Tip>
  For information about our industry-leading security practices, check out our [Security hub](https://www.fabi.ai/security).
</Tip>


# MySQL
Source: https://docs.fabi.ai/integrations_and_connectors/mysql

Connecting Fabi.ai to your [MySQL](https://www.mysql.com/) instance.

<Warning>
  Before connecting, ensure that you whitelist Fabi.ai's IP addresses in your firewall or security group settings:

  * `3.232.60.87`
  * `54.172.255.171`
</Warning>

# Creating a service account user

## 1. Log in to MySQL

Log in to your MySQL server as a user with administrative privileges:

```bash theme={null}
mysql -u root -p
```

Enter the password when prompted.

## 2. Create the service account user

```sql theme={null}
CREATE USER 'service_account'@'localhost' IDENTIFIED BY 'secure_password';
```

* Replace `service_account` with your desired username.
* Replace `secure_password` with a strong password.

## 3. Grant privileges

Fabi.ai needs read access to the schemas you wish to query.

```sql theme={null}
GRANT SELECT ON database_name.* TO 'service_account'@'localhost';
```

## 4. Apply changes

Run the following command to ensure the privileges are applied:

```sql theme={null}
FLUSH PRIVILEGES;
```

# Connecting MySQL to Fabi.ai

Once you've generated your service user credentials, follow the steps in [Connecting to Your Data](/getting_started/connect_data_sources)
<Tip>For information about our industry-leading security practices, check out our [Security hub](https://www.fabi.ai/security).</Tip>


# Neon
Source: https://docs.fabi.ai/integrations_and_connectors/neon

Connecting Fabi.ai to your [Neon](https://neon.tech/) PostgreSQL database.

<Warning>
  Before connecting, ensure that you whitelist Fabi.ai's IP addresses in your firewall or security group settings:

  * `3.232.60.87`
  * `54.172.255.171`
</Warning>

# Obtaining connection details

Connection details to connect an application to your Neon instance are available under your project on the branch you wish to connect.

Neon offers to clear step-by-step instructions [here](https://neon.com/docs/connect/connect-from-any-app), that we recommend following.

# Connecting Neon to Fabi.ai

Once you've gathered your connection details, follow the steps in [Connecting to Your Data](/getting_started/connect_data_sources)

<Tip>For information about our industry-leading security practices, check out our [Security hub](https://www.fabi.ai/security).</Tip>


# Application connectors
Source: https://docs.fabi.ai/integrations_and_connectors/other_connectors

Connect to 700+ SaaS applications and data sources via Fabi.ai application connectors.

Fabi.ai supports all [Fivetran connectors](https://fivetran.com/connectors), giving you access to 700+ pre-built connectors across every major SaaS category. Data is synced automatically on a regular schedule — no engineering required.

<Info>
  Application connectors are available on **Builder plans and above**. See [pricing](/admin_and_configuration/pricing_and_billing) for details.
</Info>

To connect an application, navigate to **Settings → Data Sources** or click **Add Data Source** in the data panel of any Smartbook.

# Connectors by category

## Marketing & Advertising

Google Ads, Facebook Ads, LinkedIn Ads, TikTok Ads, Snapchat Ads, Pinterest Ads, Microsoft Advertising, Twitter Ads, Google Campaign Manager, Google Search Console, Apple Search Ads, Criteo, AdRoll, Bing Ads

## CRM & Sales

Salesforce, HubSpot, Pipedrive, Zoho CRM, Outreach, Salesloft, Copper, Close, Freshsales, ActiveCampaign (CRM)

## E-commerce & Payments

Shopify, WooCommerce, BigCommerce, Magento, Amazon Seller Central, Recharge, Stripe, Braintree, Square, PayPal, Recurly, Chargebee

## Marketing Automation & Email

Mailchimp, Klaviyo, Braze, Marketo, Iterable, ActiveCampaign, Pardot, Campaign Monitor, Constant Contact, Customer.io, Drip, Sendgrid

## Analytics & Product

Google Analytics 4, Mixpanel, Amplitude, Segment, Heap, Pendo, FullStory, Hotjar, AppsFlyer, Adjust, Branch

## Customer Support

Zendesk, Intercom, Freshdesk, Freshservice, ServiceNow, Kustomer, Gladly, Help Scout, Dixa

## Project Management & Productivity

Jira, Asana, Monday.com, Linear, Notion, Trello, Basecamp, ClickUp, Smartsheet, Airtable

## Finance & Accounting

QuickBooks, Xero, NetSuite, Sage, Chargebee, Zuora, Recurly, Avalara, Expensify

## HR & People Ops

Workday, BambooHR, Gusto, ADP, Greenhouse, Lever, Jobvite, Rippling, Lattice, Namely, Paylocity

## Data & Cloud Storage

Amazon S3, Google Cloud Storage, Azure Blob Storage, Google Drive, Dropbox, Box, SFTP, FTP, Google Sheets

## DevOps & Engineering

GitHub, GitLab, Bitbucket, PagerDuty, Datadog, New Relic, Splunk, Jira (DevOps), CircleCI

## Events & Streaming

Apache Kafka, AWS Kinesis, Azure Event Hubs, Google Pub/Sub, Confluent Cloud

## Databases (via Fivetran CDC)

MySQL, PostgreSQL, SQL Server, Oracle, MongoDB, DynamoDB, CockroachDB, and more

***

This list is non-exhaustive. For the full list of 700+ connectors, visit the [Fivetran connector directory](https://fivetran.com/connectors).

If you need a connector that isn't listed or want help getting set up, reach out to [support@fabi.ai](mailto:support@fabi.ai).


# PostgreSQL
Source: https://docs.fabi.ai/integrations_and_connectors/postgresql

Connecting Fabi.ai to your [PostgreSQL](https://www.postgresql.org/) instance.

<Warning>
  Before connecting, ensure that you whitelist Fabi.ai's IP addresses in your firewall or security group settings:

  * `3.232.60.87`
  * `54.172.255.171`
</Warning>

# Creating a service account user

## 1. Access PostgreSQL

Open your PostgreSQL client or connect to the database server using the `psql` command-line tool:

```bash theme={null}
psql -U postgres
```

## 2. Create the service user

Use the `CREATE USER` command to define the user and assign a secure password:

```sql theme={null}
CREATE USER service_user WITH PASSWORD 'secure_password';
```

* Replace `service_user` with your desired username.
* Replace `secure_password` with a strong password.

## 3. Grant necessary privileges

Fabi.ai needs read access to the schemas that you wish to query.

To grant the ability to connect to a database:

```sql theme={null}
GRANT CONNECT ON DATABASE your_database TO service_user;
```

To give access to specific schemas:

```sql theme={null}
GRANT USAGE ON SCHEMA your_schema TO service_user;
```

To allow the user to read from tables:

```sql theme={null}
GRANT SELECT ON ALL TABLES IN SCHEMA your_schema TO service_user;
```

Optional: To automatically grant privileges on new tables:

```sql theme={null}
ALTER DEFAULT PRIVILEGES IN SCHEMA your_schema GRANT SELECT ON TABLES TO service_user;
```

[PostgreSQL Documentation: Privileges](https://www.postgresql.org/docs/current/ddl-priv.html)

# Connecting PostgreSQK to Fabi.ai

Once you've generated your service user credentials, follow the steps in [Connecting to Your Data](/getting_started/connect_data_sources)
<Tip>For information about our industry-leading security practices, check out our [Security hub](https://www.fabi.ai/security).</Tip>

# Hydra

For organizations that use PostgreSQL, we've partnered with [Hydra](https://www.hydra.so/) to provide real-time analytics on transactional databases.

Hydra is a high-performance database system that leverages DuckDB to combine transactional and analytical capabilities in one platform. It streamlines real-time analytics on live transactions and events by eliminating the need for data movement and transformation (ETL) between the transactional rowstore and the analytical columnstore.

Combining Hydra and Fabi.ai creates a powerful analytical experience leveraging AI directly on transactional databases withour compromising latency or uptime.


# Redshift
Source: https://docs.fabi.ai/integrations_and_connectors/redshift

Connecting Fabi.ai to your [Redshift](https://aws.amazon.com/redshift/) instance.

<Warning>
  Before connecting, ensure that you whitelist Fabi.ai's IP addresses in your firewall or security group settings:

  * `3.232.60.87`
  * `54.172.255.171`
</Warning>

# Creating a service account user

## 1. Log in to the AWS Management Console

Open the AWS Management Console and navigate to your Redshift cluster.

## 2. Connect to the cluster

Use a SQL client or AWS Query Editor v2 to connect to your Redshift cluster.
Documentation: Connecting to an Amazon Redshift cluster

## 3. Create the service account user

Run the following SQL command to create a new user. Replace service\_account\_user with your desired username and password with a secure password.

```sql theme={null}
CREATE USER service_account_user PASSWORD 'secure_password';
```

* Replace `secure_password` with a strong password.
* Replace `service_account_user` with the service account user name.

## 4. Assign permissions to the user

Fabi.ai needs read access to the schemas you wish to query.

```sql theme={null}
GRANT USAGE ON SCHEMA schema_name TO service_account_user;
GRANT SELECT ON ALL TABLES IN SCHEMA schema_name TO service_account_user;
```

# Connecting Redshift to Fabi.ai

Once you've generated your service user credentials, follow the steps in [Connecting to Your Data](/getting_started/connect_data_sources)
<Tip>For information about our industry-leading security practices, check out our [Security hub](https://www.fabi.ai/security).</Tip>


# Fabi for Slack
Source: https://docs.fabi.ai/integrations_and_connectors/slack_app

Bring AI-powered analytics to your team, right where they work.

Fabi for Slack brings our AI Analyst Agent directly into Slack, enabling everyone on your team to self-service analytics questions and ad hoc queries right where they work.

## Installation

<Steps>
  <Step title="Install the app">
    Visit [app.fabi.ai/slack/install](https://app.fabi.ai/slack/install) to install Fabi for Slack. You must be a Slack admin to complete the installation. If you're not an admin, ask your Slack administrator to install the app.
  </Step>

  <Step title="Invite Fabi to a channel">
    Once installed, invite Fabi to any channel by tagging it (e.g., `@Fabi`). The app will then be available to answer questions in that channel.
  </Step>
</Steps>

## Usage

Once Fabi is in a channel, simply tag the app with your question:

```
@Fabi What were our top 10 customers by revenue last month?
```

Fabi will use your connected data sources to answer the question and share the results directly in Slack.

## Requirements

* A Slack admin must install the app
* Only users with a Fabi license can tag and interact with the app


# Snowflake
Source: https://docs.fabi.ai/integrations_and_connectors/snowflake

Connecting Fabi.ai to your [Snowflake](https://www.snowflake.com/) instance.

<Warning>
  Before connecting, ensure that you whitelist Fabi.ai's IP addresses in your firewall or security group settings:

  * `3.232.60.87`
  * `54.172.255.171`
</Warning>

# Creating a service account user

Creating a service user account in Snowflake involves setting up a user with programmatic access for tasks like automation, integration, or API-based operations.

## 1. Log in to Snowflake

* Access your Snowflake account through the [Snowflake Web Interface](https://app.snowflake.com/).
* Use your administrator credentials.

## 2. Navigate to the Admin Section

Go to the **Admin** tab or click on **Account Settings** from the top-right profile menu.

## 3. Create the Service User

Use the following SQL command to create a new service user account:

```sql theme={null}
CREATE USER service_user_name
PASSWORD = 'YourStrongPassword'
DEFAULT_ROLE = service_role
DEFAULT_WAREHOUSE = service_warehouse
MUST_CHANGE_PASSWORD = FALSE;
```

Replace:

* service\_user\_name with a descriptive username (e.g., api\_service\_user).
* service\_role with the default role you want to assign (e.g., read\_only\_role).
* service\_warehouse with the default warehouse for the user.

# Connecting Snowflake to Fabi.ai

Once you've generated your service user credentials, follow the steps in [Connecting to Your Data](/getting_started/connect_data_sources)
<Tip>For information about our industry-leading security practices, check out our [Security hub](https://www.fabi.ai/security).</Tip>


# Supabase
Source: https://docs.fabi.ai/integrations_and_connectors/supabase

Connecting Fabi.ai to your [Supabase](https://supabase.com/) instance.

<Warning>
  Before connecting, ensure that you whitelist Fabi.ai's IP addresses in your firewall or security group settings:

  * `3.232.60.87`
  * `54.172.255.171`
</Warning>

# Creating a service account user

## 1. Access Supabase Dashboard

Log in to your [Supabase Dashboard](https://app.supabase.com/) and navigate to your project.

## 2. Navigate to your project and target branch

Navigate to your project in Supabase, and select the branch you want to connect to Fabi then click `Connect`

## 3. Get connection details

Once you click on `Connect`, search for one of the connection methods that's IPv4 compatible and retrieve the connection details. We recommend using `Session pooler`:

* **Host**: Your project's database host (found in Settings > Database)
* **Database name**: Usually `postgres`
* **Port**: Usually `5432`
* **Username**: Either `postgres` (with service\_role key) or your custom service user
* **Password**: Your database password that you've set

# Connecting Supabase to Fabi.ai

Once you've gathered your connection details, follow the steps in [Connecting to Your Data](/getting_started/connect_data_sources)

<Tip>For information about our industry-leading security practices, check out our [Security hub](https://www.fabi.ai/security).</Tip>


# Introduction to Fabi
Source: https://docs.fabi.ai/introduction

Fabi is an AI-native self-service analytics platform. Analyze your data, build dashboards and automate workflows with the help of our AI data analyst.

# Welcome to *the* AI-native business intelligence platform

You're about to save you and your team a whole lot of time and do things with your data that you didn't think possible.

Upload files, connect to Google Sheets, your data warehouse or any other data source and perform **ad hoc analysis**, **explore your data**, **build dashboards** and **AI-powered workflows** like never before. As a [generative BI](https://www.fabi.ai/) platform, Fabi lets you build dashboards with an embedded AI agent that automatically handles follow-up requests, or automate your tedious data workflows—all in minutes with the help of our Analyst Agent.

<Frame>
  <iframe title="Introduction to Fabi" />
</Frame>

<CardGroup>
  <Card title="Book a demo" icon="calendar" href="https://calendly.com/marc-fabi/fabi-ai-demo">
    See Fabi.ai in action with a personalized walkthrough from our team.
  </Card>

  <Card title="Start for free" icon="rocket" href="https://app.fabi.ai/">
    Sign up instantly — no credit card required.
  </Card>
</CardGroup>

## Get started in 4 easy steps in 5 minutes

<Steps>
  <Step title="Log in and create a free account">
    Sign up for Fabi.ai and get instant access to your AI-powered data analysis platform.
  </Step>

  <Step title="Connect your data or upload a file">
    Connect to your database, data warehouse, Google Sheets, or simply upload a CSV file to get started.
  </Step>

  <Step title="Start asking questions">
    Ask questions in plain English and let our AI analyst help you discover insights from your data.
  </Step>

  <Step title="Publish and share">
    Turn your analysis into a dashboard, schedule it to refresh automatically, or send insights directly to Slack where your team works.
  </Step>
</Steps>

<CardGroup>
  <Card title="Quick start" icon="rabbit-running" href="getting_started/ai_powered_data_analysis">
    How to started discovering insights from your data in minutes.
  </Card>

  <Card title="Connecting data sources" icon="database" href="getting_started/connect_data_sources">
    Connect your data sources in minutes to get the most out of Fabi.ai
  </Card>
</CardGroup>

<Tip>
  **Want to build dashboards from Claude Code or Codex?** Check out our [headless BI CLI](/advanced_features_and_dev_tools/cli) to build and deploy fully custom dashboards and apps from your favorite AI coding agent.
</Tip>

## AI-powered data analysis & reporting

Leverage the power of AI to quickly uncover insights from your data and share them with your team.

<CardGroup>
  <Card title="Upload data" icon="cloud-arrow-up" href="/analysis_and_reporting/uploading_files">
    Connect your data sources to get the most out of Fabi.ai
  </Card>

  <Card title="AI tips & tricks" icon="sparkles" href="/analysis_and_reporting/ai_tips">
    Connect your data sources to get the most out of Fabi.ai
  </Card>

  <Card title="Publish dashboards" icon="gauge" href="/analysis_and_reporting/reporting_and_collaboration">
    Ship dashboards in minutes.
  </Card>

  <Card title="Automate workflows" icon="diagram-project" href="/workflow_automation/workflows">
    Ship dashboards in minutes.
  </Card>
</CardGroup>


# AI data processing
Source: https://docs.fabi.ai/workflow_automation/ai_enrichment

Process fields using AI.

# Overview

If you want to conduct a sentiment analysis or any other type of processing best done by AI, but want to retain the original structure of your data, you can use **AI enrichment** cells.
These cells are designed to take in a DataFrame as input, process a designated field and produce the exact same DataFrame with a new, AI-generated field.

These cells are great for:

* Natural language processing
* Sentiment analysis and categorization
* Keyword analysis
* Intent categorization

<Frame>
  <img alt="ai_enrichment_cell" />
</Frame>

# How to use the AI summarization cell

1. Create a new **AI Enrichment** cell
2. Enter the name of the DataFrame you want to summarize in the **Input** field
3. Enter the name of the field you want to enrich or process in the **Column for AI to process** field
4. Enter the name of the DataFrame to produce in the **Output DataFrame name** field
5. Enter the name of the new field for the AI to generate in the **Column containing the AI output** field
6. Enter the prompt you want to use to summarize the data
7. Click **Run** or **Preview**

This cell will generate a new DataFrame that looks exactly like the input DataFrame, except for the additional AI-generated field.

<Note>
  **Important**: By default AI summarization cells will run in **Preview** mode. This means that the AI will only sample part of the data and will
  not automatically run when changes are made upstream or downstream. In order to run the AI summarization cell on the entire dataset, you can change the run mode by clicking the dropdown on the **Run** button.
</Note>

<Frame>
  <img alt="switching_run_modes" />
</Frame>


# AI summaries
Source: https://docs.fabi.ai/workflow_automation/ai_summarization

Generate summaries of your data with AI.

# Overview

Fabi.ai has a built-in AI summarization cell that allows you to summarize text data.

This is perfect for:

* Sending our executive summaries via email or Slack
* Including up-to-date summaries embedded in your dashboards

<Frame>
  <img alt="ai_summarization_cell" />
</Frame>

# How to use the AI summarization cell

1. Create a new **AI Summarization** cell
2. Enter the name of the DataFrame you want to summarize in the **Input** field
3. Enter the name of the Python variable that you want to store the AI summary in, in the **Output variable name containing the summary** field
4. Enter the prompt you want to use to summarize the data (eg. "Write a brief executive summary")
5. Click **Run** or **Preview**

The AI summary will be stored as a Python string in the variable that you've defined in the output. You can then use this Python string in subsequent cells or send emails or Slack messages for example, or even include in Text cells.

<Note>
  **Important**: By default AI summarization cells will run in **Preview** mode. This means that the AI will only sample part of the data and will
  not automatically run when changes are made upstream or downstream. In order to run the AI summarization cell on the entire dataset, you can change the run mode by clicking the dropdown on the **Run** button.
</Note>

<Frame>
  <img alt="switching_run_modes" />
</Frame>


# Pull from Airtable
Source: https://docs.fabi.ai/workflow_automation/pull_from_airtable

Use AI, SQL and Python to explore your Airtable data

# Overview

The Airtable input cell allows you to fetch data from your Airtable bases and use it in your workflows, analyses, and Airtable dashboards. Airtable views are automatically stored at Python DataFrames for easy use with AI and Python or SQL.

## Configuration

### Creating an Airtable access token

In Airtable, create a new API access token from your [Builder Hub](https://airtable.com/create/tokens).

Make sure this token as `data.records:read` access so that it can read your data from Airtable.

### Ingesting Airtable views into Fabi.ai

Once you have your Airtable access token:

1. In a Smartbook, create a new Airtable cell
2. Copy/paste the view URL from Airtable in the **View URL** input (eg. "[https://airtable.com/app1lxz7](https://airtable.com/app1lxz7)")
3. Add you access token to the **Personal Access Token** input (**Important**: We strongly recommend using our [Secret Manager](../advanced_features_and_dev_tools/secret_manager) for better security)

<Frame>
  <img alt="airtable_cell" />
</Frame>

As with other input cells, Fabi.ai automatically saves your data as a Python DataFrame to make it ready to use for the AI or in any other cell.


# Pull from Google Sheets
Source: https://docs.fabi.ai/workflow_automation/pull_from_google_sheets

Pulling data from Google Sheets into Fabi.ai

# Overview

Our **Pull from Google Sheets** cell let's you pull data from a Google Sheets and automatically save it as a DataFrame.

Once you've pulled your data in, you can easily analyze it using Python and AI and build dashboards and workflows with it.

<Frame>
  <img alt="python_dataframe" />
</Frame>

# Configuring your Google Sheets pull

Steps to set up your first pull:

1. In Smartbook or workflow, add a new cell and select **Google Sheet Pull**
2. Connect your Google Workspace account
3. Click on **Select File** and search for the sheet you want to pull data from
4. Run the cell

<Note>
  **Note**: We offer two cells to pull from Google Sheets: one for private sheets and one for public sheets.
</Note>

Your sheet will automatically be saved as a new Python DataFrame which you can then use in subsequent cells.


# Push to Google Sheets
Source: https://docs.fabi.ai/workflow_automation/push_to_google_sheets

Push data from Fabi to a live Google Sheets dashboard automatically—no copy/pasting required.

# Overview

If you're doing an analysis for a stakeholder that lives in spreadsheets (FP\&A, we're looking at you), when you share a Dashboard or data app with them, there's a good chance that the first thing they do is export the data.

We want you to be able to meet your stakeholders where they are. With the push-to-Google Sheets functionality, you can do your entire analysis within Fabi.ai (or even build complex prediction models) and push that data to a live Google Sheets dashboard in just a few clicks.

This is also useful functionality if you or your team need to provide regular executive reports in Google Slides and don't want to deal with the tedious task of copy/pasting data on a weekly basis.

# Preparing the DataFrame

Start by creating your Python DataFrame. You can simply write a SQL query using a SQL cell, which will automatically generate a DataFrame as shown in the following screenshot with `dataframe1`:

<Frame>
  <img alt="sql_to_python_dataframe" />
</Frame>

Or you can create a DataFrame in Python as shown here:

<Frame>
  <img alt="python_dataframe" />
</Frame>

In the example above, we're using a machine learning model to cluster NBA players by certain attributes in order to group them (hint, this feature is great for building custom lead scoring or churn prediction models or A/B test analysis and sharing with non-technical stakeholders).

# Configuring Google Sheets

Once you've created your DataFrame, add a new **Google Sheets Push** cell to your Smartbook or workflow.

<Frame>
  <img alt="export_dataframe_to_google_sheets" />
</Frame>

In the cell, select the DataFrame you want to push to Google Sheets and configure the following:

* **Sheet URL**: The URL of the Google Sheet you want to push data to
* **Worksheet Name**: The name of the sheet you're pushing the data to
* **Push Mode**: Whether you want to override the existing spreadsheet on every update or create a new sheet

# Scheduling updates

Once you've created your DataFrame and configured the Google Sheet, don't forget to schedule and publish the Dashboard or data app, which will determine the refresh frequency of your spreadsheet. For more information on how to publish and schedule dashboards, see our documention on [Building Dashboards & data apps](https://docs.fabi.ai/analysis_and_reporting/reporting_and_collaboration#building-smart-reports).


# Sending emails
Source: https://docs.fabi.ai/workflow_automation/send_emails

Build and send emails with SQL and Python

# Overview

Email is an excellent way to schedule and send insights and dashboards. We all know executive live in their inbox, best to meet them where they are.

With our **Email Send** cell, you can quickly compose emails with Python variables and objects.

<Frame>
  <img alt="python_dataframe" />
</Frame>

# Configuring email sends

Steps to set up your first pull:

1. In Smartbook or workflow, add a new cell and select **Send Email**
2. Compose your message and insert Python variables using `{{your_dataframe}}`
3. Run the cell

Here's an example message using two DataFrames and an image:

````html theme={null}
Hey there,

Here are the top users in terms of increased widget creation:
{{top_increases}}

Here are the top users in terms of decreased widget creation:
{{top_decreases}}

Users created by month:
{{fig}}```
````


# Slack integration
Source: https://docs.fabi.ai/workflow_automation/slack_integration

Automated and scheduled Slack alerts.

<Warning>
  **Important**: Handle Slack tokens with care. [More on how to securely store and use secrets](../advanced_features_and_dev_tools/secret_manager).
</Warning>

# Overview

Slack is a great channel to share dashboards and alerts. With Python and AI, creating a Slackbot catered to your specific needs has never been easier.

Here are some examples of alerts and dashboards you may want to create:

* Automated alerts based on a certain metric threshold. For example if your weekly active users drop by a certain percentage.
* Weekly marketing pipeline dashboards
* Lists of self-service onboarded users in the past 24 hours

Your options are limitless and fully customizable to your needs.

# Step-by-step guide to creating a Slackbot

<Note>This step requires admin access to your Slack workspace.</Note>

## Step 1: Creating a Slack app and token

To create these alerts and scheduled Slack dashboards, we're going to create a custom Slack app. Start by navigating to the [Slack app API page](https://api.slack.com/apps) and click **Create New App**.

Follow these steps:

1. Opt in to **Create from scratch**
2. Provide a name and the workspace you want the app to be added to
3. Click **Create App**

Once your app is create, on the left hand side, select *OAuth & Permissions*, then follow these steps:

1. Under **Scope** and **Bot Token Scopes** click **Add an OAuth Scope**. If the bot is going to send messages to Slack, make sure you select the `chat:write.public` scope. This scope allows the app to write to publich channels they're not a part of. If you need to add the app to private channels or chats, you will need to select additional scopes.
2. Under **OAuth Tokens** on that same page, click **Install to your\_workspace**
3. Once the app is invited to your workspace, take note of the token. Your token should start with `xoxb-`. If it doesn't, you may not have generated a bot token

<Note>Please handle tokens with care and never commit tokens to code repositories.</Note>

## Step 2: Configuring your Slack message

Now that you have your Slack bot token, we can configure the message you want to send to Slack.

<Frame>
  <img alt="python_dataframe" />
</Frame>

Start by querying your data and storing the data you want to share as a Python DataFrame string or image. Then follow these steps:

1. Insert a new cell in your Smartbook or workflow and select **Slack Send**
2. Add your bot token to the **Token** input
3. Compose your message and insert Python variables using `{{your_dataframe}}`

Here's an example message using two DataFrames and an image:

```html theme={null}
Latest marketing campaign performance summary:
{{ai_marketing_campaign_summary}}

Here are the top users in terms of increased widget creation:
{{top_increases}}

Here are the top users in terms of decreased widget creation:
{{top_decreases}}

Users created by month:
{{fig}}
```

## Step 3: Scheduling your updates

Once you've created your Slack cell with the message you want to send and verified that it works, you can now schedule your app to run at whatever cadence you would like.

<Warning>Just remember that if you're app requires a query, scheduled runs will run that query. Consider the impact on your data warehouse and compute costs</Warning>

Scheduling your bot to run is the same as scheduling a dashboard. Check out our [page on scheduling](/analysis_and_reporting/schedule_reports_and_workflows.mdx) to learn more.


# Building AI data workflows
Source: https://docs.fabi.ai/workflow_automation/workflows

The quickest way to build powerful, AI-driven workflows on your data.

# Automate AI data workflows

The power of Fabi.ai doesn't just lie in your ability to conduct advanced data analysis and build dashboards incredibly fast.

We also offer the most powerful way to harness **generative AI for data analytics**—building and automating data analysis and data science pipelines end to end.

Here are some of the things you can do with our AI workflow automation:

* Schedule and process data from SQL databases or Google Sheets using Python and AI
* Send dynamic, context-relevant insights to Slack
* Automate data cleaning with SQL, Python and AI

The possibilities are endless.

<Frame>
  <img alt="workflows" />
</Frame>

# Fabi.ai workflows 101

## Cells (nodes)

The concept of cells and nodes are interchangeable. A cell is simply a building block in your workflow, and a Smartbook for that matter.

Some of our most popular cells include:

* Python
* SQL
* [AI summarization](/workflow_automation/ai_summarization)
* [AI enrichment](/workflow_automation/ai_enrichment)
* [Push to Google Sheets](/workflow_automation/push_to_google_sheets)
* [Pull from Google Sheets](/workflow_automation/pull_from_google_sheets)
* [Send to Slack](/workflow_automation/slack_integration)
* [Send to email](/workflow_automation/send_emails)

<Frame>
  <img alt="python_cell" />
</Frame>

These cells can generally do one of three things:

1. Pull data from a source (examples: SQL, Google Sheets)
2. Process data (examples: SQL, Python, AI agent)
3. Send data to a destination (examples: Google Sheets, Email, Slack)

## Edges

Cells are connected using Python variables and objects. Let's take a simple example. Say you want to pull data using SQL and process it using Python.

1. Create a SQL cell and query your data. Your data will automatically be stored in a DataFrame with the name displayed at the bottom of the cell
2. Create a Python cell that references that DataFrame. This automatically connects those two cells and creates an Edges

This logic can be extended to all cell types and different variables and objects such as strings, DataFrames and images.

<Note>
  **Important**: In Python cells you can simply refers to variables and objects directly using the name of the variable or object. In all other cells you need to indicate that these are variables using `{{your_variable_name}}`.
</Note>

Here's an example of this in action in an email cell:

<Frame>
  <img alt="python_dataframe" />
</Frame>