# Agent Capabilities
Source: https://docs.tensorstax.com/agent-capabilities
Learn what TensorStax agents can do and the verification processes they use
## Overview
TensorStax agents are designed to verify every action they take, ensuring reliability and accuracy in your data workflow. The agent provides real-time feedback and validation for all operations it performs.
### dbt Models
**Creation & Editing**: Write new dbt models and edit existing ones with automatic verification.
* Auto-generates preview of model output
* Automatic error detection and fixing
* File versioning for all changes
* Can edit existing dbt models, YML files, tests, and macros
### Tests
**Automated Testing**: Create and execute dbt tests with real-time results.
* Tests auto-execute after creation
* Agent receives immediate pass/fail feedback
* Test results visible to users
* Ensures data quality validation
### YML Files
**Schema Management**: Create and maintain YML configuration files.
* Schema definitions and documentation
* Test configurations
* Model properties and metadata
### Safety Restrictions
**Execution Boundaries**: The agent cannot perform destructive operations.
* **Cannot** execute `dbt build`, `dbt run`, or change tables
* **Cannot** modify database state directly
* Users must press the play button to run models
* Read-only access to database schemas and metadata
### DAG Creation & Editing
**DAG Management**: Create new DAGs and edit existing ones with custom operators.
* Create new Airflow DAGs from scratch
* Edit and modify existing DAG configurations
* Use custom operators tailored to your workflows
* Full DAG lifecycle management
### DAG Simulation
**In-Memory Testing**: Simulate DAG execution without running actual tasks.
* Uses TensorStax custom Airflow compiler
* Simulates DAG execution in memory
* Validates DAG structure and dependencies
* No actual task execution or resource consumption
### Script Creation & Sync
**Glue Script Management**: Create scripts and sync them directly to your AWS environment.
* Create new Glue scripts from scratch
* Automatic sync back to customer's AWS account
* Full integration with AWS Glue service
* Version control and script management
### Interactive Testing
**Live Code Testing**: Test code snippets before finalizing scripts.
* Spin up interactive Glue sessions
* Test code snippets in real-time
* Validate logic before creating final scripts
* Safe testing environment
### AWS Context Integration
**Full AWS Glue Context**: Access to your complete Glue environment.
* Context into Glue connections and databases
* Access to tables, crawlers, and metadata
* Integration with existing Glue resources
* User must press play button to execute scripts
### SELECT Queries & File Management
**Query Execution & Storage**: Run SELECT queries and manage SQL files.
* Execute SELECT queries directly against your database
* Save .sql files in your project for reuse
* Edit existing .sql files with real-time validation
* Preview table changes when editing existing files
### CREATE Statements
**DDL Query Writing**: Write CREATE TABLE and CREATE VIEW statements with preview.
* Write CREATE TABLE and CREATE VIEW queries
* Build on top of existing tables and data
* Preview data output before execution
* Verification against database schema
* User must press play button to execute
### UPDATE & INSERT Statements
**DML Query Writing**: Write UPDATE and INSERT queries with diff preview.
* Write UPDATE queries with change preview
* Incremental inserts from source to type 2 tables
* Data diff preview showing what will change
* No actual table modifications until play button pressed
* Full verification before execution
### Script Execution
**Local Python Processing**: Execute Python scripts on available data.
* Execute regular Python scripts on local CSV files
* Process and analyze data using Python libraries
* Safe execution environment for data exploration
* Integration with existing data sources
### API Structure Analysis
**Pre-Integration Validation**: Check API structures before building data pipelines.
* Analyze API structures and endpoints
* Validate data formats before creating Glue scripts
* Test API responses before building Airflow DAGs
* Ensure compatibility with ingestion workflows
### Environment Variables
**Secure Configuration Management**: Access environment variables stored in Vault.
* Use environment variables set up in HashiCorp Vault
* Secure access to API keys and credentials
* Configuration management for scripts and workflows
* Encrypted variable storage and retrieval
**Verification First**: Every action taken by TensorStax agents includes built-in verification to ensure accuracy and prevent errors from propagating through your data pipeline.
# Airflow Projects
Source: https://docs.tensorstax.com/airflow-projects
Create and manage Airflow projects with TensorStax
## Overview
Docs coming soon
# Autonomous Mode
Source: https://docs.tensorstax.com/autonomous-mode
Choose between autonomous execution or human-in-the-loop mode for your agent sessions
## Overview
TensorStax offers two execution modes to match your workflow preferences and project requirements. Choose between full autonomous execution or human-in-the-loop mode for greater control over the agent's actions.
## Mode Options
**Interactive Control**: The agent asks for confirmation after every plan step and before the session begins.
* Review and approve each step before execution
* Request plan updates before the agent starts
* Redo any step as many times as needed
* Move to the next step only when you're satisfied
Even in human-in-the-loop mode, TensorStax will automatically attempt to fix dbt model errors on its own before asking for your input.
**End-to-End Execution**: The agent executes the complete plan without interruptions.
* Runs the entire plan from start to finish
* Self-corrects when errors occur
* Automatically retries failed steps
* Continues until the expected result is achieved
**Flexible Corrections**: Regardless of execution mode, you can always make changes afterward.
* Use Quick Edit for simple modifications
* Access Open Editor View for comprehensive changes
* Manual file editing is always available
* Make adjustments even after autonomous completion
## Choosing the Right Mode
* Working on critical production models
* Learning how TensorStax approaches problems
* Need to review each step for compliance
* Want to customize the approach mid-execution
* Prototyping or exploring data
* Working on non-critical development tasks
* Trust the agent's decision-making
* Need fast iteration and results
**Best Practice**: Start with human-in-the-loop mode for new projects to understand TensorStax's approach, then switch to autonomous mode for similar tasks once you're comfortable with the patterns.
# Context
Source: https://docs.tensorstax.com/context
Configure context for your agent sessions and data analysis
## Overview
Agent sessions are the core of TensorStax's Agentic Data OS. Before you can start asking questions or running analysis, you need to configure the context that defines which data sources and tables your agent will work with.
## Getting Started with Context
The first and most important step in any agent session is selecting your context. Context tells the agent which materialized tables it should focus on for your analysis.
**dbt Model Integration** - TensorStax automatically maps your materialized tables to their source dbt models and pulls the complete lineage including source models, YAML configurations, tests, and macros. This allows TensorStax to create new models following your existing patterns and edit existing files when needed.
### Context Configuration
The primary component of your context is selecting which materialized tables you want to work with. You can:
* **Search for tables**: Use the search functionality to quickly find specific tables
* **Browse available tables**: Use the dropdown to explore all available materialized tables
* **View table schema**: Once selected, you'll see all columns available in each table
This selection determines what data the agent can access and analyze during your session.
When you select materialized tables, TensorStax automatically:
* Shows all column names and data types
* Displays table relationships and dependencies
* Pulls the complete DDL (Data Definition Language) for the table in the background
This schema information helps the agent understand your data structure and provide more accurate analysis.
**Important**: TensorStax by default never sees your raw data. The system only accesses table schemas and metadata to understand your data structure.
However, you have the option to **"Include Sample Row"** which will:
* Pull the first row from your database
* Provide the agent with actual data examples
* Enable more sophisticated analysis tasks like flattening nested JSON fields
* Help with data type inference and validation
Only enable "Include Sample Row" when you're comfortable sharing a sample of your data with the analysis engine.
Once you've configured your context:
1. **Review your selections**: Confirm the tables and settings are correct
2. **Apply context**: Click apply to activate your configuration
3. **Background processing**: TensorStax builds lineage mapping your materialized tables to their source dbt models, tests, and macros
4. **Ready for analysis**: Your agent session is now ready for questions and tasks
The context remains active throughout your session and can be modified as needed.
Enabling sample rows is useful for JSON field analysis, data type validation, and complex transformations that require actual data examples.
**Privacy First**: TensorStax only accesses your table schemas and DDLs by default - your raw data remains private and secure unless you explicitly enable sample rows.
## JIRA Integration
Pull JIRA tickets and have TensorStax work on them autonomously in the background, creating models and updating ticket status.
# Custom Rules
Source: https://docs.tensorstax.com/custom-rules
Set custom business logic and rules that TensorStax will follow for each connected service
## Overview
Custom rules allow you to define specific business logic and standards that TensorStax will consistently follow when working with your connected services. Once set, these rules are automatically applied every time the agent interacts with the corresponding service.
## Service-Specific Rules
### dbt Rules
Define standards and patterns for dbt model creation and management.
* Naming conventions for models, tests, and macros
* Required documentation standards
* Model materialization preferences
* Testing requirements and coverage rules
* Folder structure and organization patterns
### SQL Rules
Set guidelines for SQL query generation and database interactions.
* Query formatting and style preferences
* Table and column naming conventions
* Performance optimization requirements
* Security and access control standards
* Data type and constraint preferences
### Airflow Rules
Configure standards for DAG creation and workflow management.
* DAG naming and tagging conventions
* Task dependency patterns and best practices
* Retry and timeout configurations
* Resource allocation guidelines
* Scheduling and trigger preferences
### Python Rules
Establish coding standards and practices for Python scripts.
* Code formatting and style guidelines
* Library and package preferences
* Error handling and logging standards
* Documentation and commenting requirements
* Performance and optimization rules
### AWS Glue Rules
Define standards for Glue script creation and ETL processes.
* Job naming and configuration standards
* Resource allocation and scaling rules
* Data format and transformation preferences
* Error handling and monitoring requirements
* Security and IAM role specifications
## Rule Management
**Consistent Application**: Once configured, custom rules are automatically enforced across all agent interactions with the respective services, ensuring consistency and compliance with your organization's standards.
### Rule Configuration
* **Service-Level Rules**: Set rules that apply to all operations within a specific service
* **Project-Level Rules**: Define rules that apply across multiple services within a project
* **Global Rules**: Establish organization-wide standards that apply to all projects and services
### Rule Enforcement
* **Automatic Validation**: Rules are checked and enforced during code generation
* **Real-Time Feedback**: Immediate notifications when rules cannot be satisfied
* **Compliance Reporting**: Track adherence to custom rules across all operations
**Best Practice**: Start with essential rules for naming conventions and security standards, then gradually expand to include style preferences and optimization guidelines as your team becomes familiar with the system.
# Connecting Your Data
Source: https://docs.tensorstax.com/data-connections
Learn how to connect your databases to TensorStax
## Overview
**Security** - Your database credentials are now safely encrypted and stored. All credentials are secured in an isolated HashiCorp Vault.
TensorStax makes it easy to connect your data sources securely. Follow this step-by-step guide to set up your database connections.
## Connection Steps
Navigate to the **Integrations** panel on the left sidebar of your TensorStax dashboard.
Click the **Create New Connection** button in the top right corner of the integrations page.
Fill in your database credentials in the connection form. All credentials are securely encrypted before storage.
If you're connecting to Snowflake, you can choose to connect to specific databases or select all databases.
The system will test your connection to ensure everything is configured correctly.
Upon successful connection, you'll see the confirmation screen indicating your database credentials are now safely encrypted and stored.
## Security
Make sure to have your database credentials ready, including host, port, username, and password.
* All database credentials are encrypted before storage
* Credentials are stored in an isolated HashiCorp Vault
* Connections use industry-standard security protocols
* Access is controlled through role-based permissions
## Supported Databases
Cloud data warehouse with scalable compute and storage.
Open-source relational database with advanced features.
Popular open-source relational database management system.
Google Cloud's serverless data warehouse for analytics.
Scalable object storage for data archiving and backup.
Coming Soon - Unified analytics platform for big data and ML.
TensorStax supports many more database types. Contact support if you need help connecting a specific database.
## Troubleshooting
If your connection test fails:
* **Verify credentials**: Double-check your username, password, host, and port
* **Check network access**: Ensure your database allows connections from TensorStax IP addresses
* **Firewall settings**: Verify your network firewall allows the connection
* **Database permissions**: Confirm your user has the necessary permissions
If the connection is taking too long:
* Check your internet connection
* Verify the database server is responsive
* Consider if there are any network latency issues
Contact our support team if issues persist. Include:
* Database type and version
* Error messages received
* Network configuration details
## Next Steps
Explore your database tables, views, and relationships.
Get started by cloning your repository.
# Data Viewer
Source: https://docs.tensorstax.com/data-viewer
Browse and explore your database tables, views, and raw data
## Overview
Browse your connected databases, select tables, and view raw data for all your connected data sources.
## Features
* Select databases and tables from any connected data source
* View table schemas and column definitions
* Browse raw data with pagination
* Explore relationships between tables
**Data Privacy**: Only metadata is accessed by default unless you explicitly enable data sampling.
# Environment Variables
Source: https://docs.tensorstax.com/dbt-env-vars
Configure environment variables for your dbt profiles using HashiCorp Vault
## Overview
Environment variables are securely stored in HashiCorp Vault and used to configure your dbt profiles.yml file. This allows you to keep sensitive credentials separate from your code while maintaining secure access to your data sources.
## How It Works
When you set up environment variables in TensorStax:
1. **Secure Storage**: All environment variables are encrypted and stored in HashiCorp Vault
2. **Automatic Integration**: Variables are automatically injected into your dbt runtime environment
3. **Profile Configuration**: Your profiles.yml file references these variables using the `env_var()` function
## Setting Environment Variables
Navigate to your dbt project settings and add the required environment variables for your data source connections. Common variables include:
* Database credentials (username, password)
* Connection details (account, warehouse, database)
* Role and schema information
## Example profiles.yml Configuration
Here's how your profiles.yml file would reference the environment variables:
```yaml
snowflake_dbt_demo:
outputs:
dev:
type: snowflake
account: "{{ env_var('DBT_SNOWFLAKE_ACCOUNT') }}"
user: "{{ env_var('DBT_SNOWFLAKE_USER') }}"
password: "{{ env_var('DBT_SNOWFLAKE_PASSWORD') }}"
role: "{{ env_var('DBT_SNOWFLAKE_ROLE') }}"
database: "{{ env_var('DBT_SNOWFLAKE_DATABASE') }}"
warehouse: "{{ env_var('DBT_SNOWFLAKE_WAREHOUSE') }}"
schema: "{{ env_var('DBT_SNOWFLAKE_SCHEMA') }}"
threads: 4
target: dev
```
## Security Benefits
All environment variables are encrypted at rest in HashiCorp Vault.
Role-based access controls determine who can view or modify variables.
## Best Practices
Use clear, descriptive names with prefixes to identify the service:
* `DBT_SNOWFLAKE_ACCOUNT`
* `DBT_POSTGRES_HOST`
* `DBT_BIGQUERY_PROJECT`
Regularly rotate sensitive credentials like passwords and API keys for enhanced security.
Only set the environment variables that are actually needed for your dbt project.
Grant environment variable access only to team members who need it for their work.
## Next Steps
Set up your dbt profiles to use these environment variables.
Test your database connections to ensure variables are configured correctly.
# Setting Up Your Repo
Source: https://docs.tensorstax.com/dbt-setup
Configure and manage your dbt transformations
## Overview
Set up your dbt repository in TensorStax using one of three methods: pull from GitHub, create a TensorStax managed project, or pull from GitLab.
## Getting Started
For all three options, you'll need to:
1. Navigate to the **dbt Projects** page
2. Click **Dashboard** on the top right
3. Choose your preferred setup method from the three options presented
If your dbt folder is in a broader data engineering repo, you can specify the right subdirectory such as `analytics/dbt` at the time of setup or later in the **Settings** page.
## Repository Integration
Make sure you have already connected your GitHub or GitLab account in the Repository Cloning section.
### GitHub
1. From the dashboard, click **Clone from GitHub** to connect your existing dbt project.
2. Choose the right repository from your connected GitHub repositories.
3. Complete the setup process and start working with your dbt models.
### GitLab
1. From the dashboard, click **Clone from GitLab** to connect your existing dbt project.
2. Choose the right repository from your connected GitLab repositories.
3. Complete the setup process and start working with your dbt models.
## TensorStax Managed Project
1. From the dashboard, click **TensorStax Managed** to create a new dbt project managed entirely within TensorStax.
2. Select at least 1 connected data source for your dbt project.
3. You can add more databases to your profiles later as needed.
This option is perfect for getting started quickly without external repositories. We automatically set up the environment variables and profiles.yml for you with HashiCorp Vault. Make sure you have connected your data sources in the Data Connections section first.
## Prerequisites
Before setting up your dbt repository, ensure you have:
Your database must be connected to TensorStax first.
For GitHub/GitLab options, ensure repository access is configured.
## Next Steps
Start building your data models and transformations.
Add tests and documentation to your dbt project.
Set up automated runs for your dbt models.
Explore advanced dbt features and optimizations.
# Lineage
Source: https://docs.tensorstax.com/lineage
Visualize and explore your complete dbt project lineage
## Overview
The Lineage page provides a comprehensive view of your entire dbt project's data flow. You can visualize how your models, sources, tests, seeds, and snapshots connect to each other, making it easy to understand data dependencies and relationships.
## Building Lineage
### First Time Setup
If you're viewing lineage for the first time, click the **Build Lineage** button to generate your project's lineage graph.
### Refreshing Lineage
To refresh your lineage after making changes to your dbt project:
1. Click the **Build Lineage** button
2. TensorStax will rebuild your lineage in a few hundred milliseconds
3. This is significantly faster than native dbt lineage generation
TensorStax's lineage building is optimized for speed, typically completing in under 500ms compared to several seconds with native dbt.
## Lineage Settings
Access lineage settings to customize your view and control what information is displayed.
### Upstream Tracing
* **Enable Upstream Tracing**: Toggle this option to show or hide upstream dependencies in your lineage view
### Node Types
Control which types of nodes are visible in your lineage:
Select this to show all node types in your lineage visualization.
Show only dbt models in the lineage view.
Display source tables and their connections.
Include dbt tests in the lineage visualization.
Show seed files and their downstream dependencies.
Display snapshot models in the lineage.
# Quick Inline Edit
Source: https://docs.tensorstax.com/quick-edit
AI-powered dbt assistant with full lineage context
## Overview
Quick Inline Edit is a terminal-based AI assistant that's very fast and accurate at writing dbt code. It has context into the full lineage of models based on the selected model by default, making it incredibly powerful for dbt development.
## Key Features
* **Full Lineage Context**: Understands the complete model lineage and dependencies
* **Context Visibility**: View the context through the lineage bar at the top of the dbt model content
* **Sources Integration**: Click to see and include source definitions in context
* **Multi-file Editing**: Edit multiple files simultaneously across the lineage
* **Q\&A Capability**: Answer questions about model relationships and lineage
* **Real-time Speed**: The attached GIF is not sped up - edits happen instantly
## How to Use
1. **Select a model** to automatically load its lineage context
2. **Access Quick Inline Edit** through the terminal:
* Type `/` followed by your edit request (e.g., `/remove comments`)
* Or type `/edit` and press Enter to enter full edit mode
3. **Ask questions or request edits** - The AI understands the full lineage and can answer questions about model relationships
4. **View the lineage bar** at the top to see what context Quick Inline Edit has
5. **Use Cmd+Enter** to accept all suggested edits across multiple files
Quick Inline Edit can modify multiple files at once based on lineage relationships, making complex refactoring tasks much faster.
## Example Use Cases
Ask Quick Inline Edit to refactor a model and it will automatically update all downstream dependencies across multiple files.
"What models depend on this source?" or "How is this field calculated?" - Quick Inline Edit understands your entire data flow.
Add or modify columns and Quick Inline Edit will propagate the changes through your lineage where appropriate.
Quick Inline Edit can see your source definitions and help you build models that properly reference and transform source data.
## Context Understanding
Quick Inline Edit's power comes from its deep understanding of your dbt project:
* **Model Dependencies**: Knows which models depend on each other
* **Source Definitions**: Understands your source tables and their schemas
* **Column Lineage**: Tracks how columns flow through transformations
* **Business Logic**: Understands the purpose and transformations in your models
## Multi-File Editing
When you make changes that affect multiple models, Quick Inline Edit can:
* Update all related models simultaneously
* Maintain consistency across your lineage
* Ensure referential integrity
* Apply consistent naming conventions
Use `Cmd+Enter` to accept all suggested changes across multiple files at once.
# Repository Cloning
Source: https://docs.tensorstax.com/repository-cloning
Connect and clone your GitHub and GitLab repositories
## Overview
TensorStax allows you to connect and clone repositories from GitHub and GitLab for seamless code management and deployment.
## Repository Integration
The process for connecting GitHub and GitLab repositories is identical. Follow these steps for either platform:
First, click on the **Integrations** tab at the top of the integrations page to swap from data connectors to other integrations.
Click **Connect** under either the GitHub or GitLab section to begin the OAuth flow.
You'll be redirected to your chosen platform (GitHub or GitLab) to authorize TensorStax access to your repositories.
During the OAuth flow, you'll be able to select which repositories you want TensorStax to be able to clone.
You can always modify repository access later in your platform's settings (GitHub or GitLab).
Once you complete the OAuth flow and return to TensorStax, refresh the page to see the repositories you selected.
## Next Steps
Configure and manage your dbt transformations.
Create and orchestrate data workflows with Apache Airflow.
Develop and manage your SQL-based data projects.
Explore your database tables, views, and relationships.
# Semantic Search
Source: https://docs.tensorstax.com/semantic-search
Intelligent search for models, errors, and context across your dbt project
## Overview
Semantic Search provides an intelligent search experience that goes beyond simple file name matching. Search for errors, ask questions about models, or find files by context - all processed in real-time with no pre-built indexes.
## How It Works
The search bar understands natural language queries and semantic context:
* **Error Search**: Type error messages to quickly locate the problematic files
* **Contextual Queries**: Ask questions about models and their functionality
* **File Name Search**: Traditional file name searches work seamlessly
* **Macro Discovery**: Find macros by describing what they do
## Performance
**Under 500ms** - Fast results for typical dbt projects
**Under 5 seconds** - Even projects with 1000s of files return results quickly
## Real-Time Processing
**No indexes stored** - Everything is computed in memory to ensure the most up-to-date results. Changes to your project are immediately searchable without rebuilding indexes.
## Search Examples
### Error Detection
* Type error messages from your dbt runs
* The search will identify which specific files contain the errors
* Get direct navigation to problematic code
### Model Questions
* "Find the model that calculates customer lifetime value"
* "Show me models that use the orders table"
* "Which model handles revenue calculations"
### Macro Discovery
* "Find macro that formats dates"
* "Show me the macro for data quality checks"
* "Macro that handles null values"
### File Search
* Standard file name searches work alongside semantic queries
* Partial names and patterns are supported
* Case-insensitive matching
## Key Features
* **Context-Aware**: Understands the purpose and functionality of your models
* **Error-Focused**: Quickly pinpoint files causing build failures
* **No Maintenance**: No indexes to rebuild or maintain
* **Always Current**: Searches reflect your latest code changes immediately
* **Natural Language**: Ask questions in plain English
Try combining different search approaches - you can search for errors, then follow up with contextual questions about the affected models.
# Smart Shell
Source: https://docs.tensorstax.com/smart-shell
Intelligent command-line interface with smart autocompletion
## Overview
Smart Shell provides an intelligent command-line interface that combines traditional terminal functionality with smart autocompletion. Execute dbt commands, Git operations, and standard Linux commands with intelligent assistance. The terminal knows about which files exist in your repository for enhanced suggestions.
Try asking questions in natural language and pressing Tab to get the right command suggestions for your needs.
## Smart Autocompletion
The special feature of Smart Shell is its intelligent autocompletion. When you:
1. **Type a partial command** and press `Tab`
2. **Ask a question** and press `Tab`
3. **Need help with syntax** and press `Tab`
The terminal will automatically suggest or complete the appropriate command for you.
### Example Interactions
**Question:** "how do i verify if my dbt profiles set up right"
**Press Tab** → Auto-completes to: `dbt debug`
This command checks your dbt configuration and profile setup.
**Question:** "dbt show dim suppliers"
**Press Tab** → Auto-completes to: `dbt show --select marts.core.dim_suppliers`
Displays a sample of data from your dim\_suppliers model with proper path resolution.
**Question:** "how do i test my data"
**Press Tab** → Auto-completes to: `dbt test`
Runs all tests defined in your dbt project.
**Question:** "show me commits from last week with file changes"
**Press Tab** → Auto-completes to: `git log --since="1 week ago" --stat --oneline`
Displays commits from the last week with file change statistics in a compact format.
## Supported Commands
* `dbt run` - Execute models
* `dbt test` - Run tests
* `dbt debug` - Check configuration
* `dbt compile` - Compile models
* `dbt docs generate` - Generate documentation
* And all other standard dbt commands
* `git status` - Repository status
* `git add` - Stage changes
* `git commit` - Commit changes
* `git push` - Push to remote
* `git pull` - Pull from remote
* And all other Git operations
* `ls` - List directory contents
* `cd` - Change directory (within project)
* `cat` - Display file contents
* `grep` - Search text
* `find` - Find files
* And other standard Linux utilities
## Security Restrictions
For security and project integrity, certain commands are restricted:
**Restricted:** `cd` commands that navigate outside the dbt project directory
**Reason:** Keeps you within your project workspace for security
**Restricted:** `sudo` commands and other privileged operations
**Reason:** Prevents unauthorized system-level changes
**Restricted:** Commands that could damage the system or other projects
**Reason:** Maintains environment stability and security
## Quick Actions
For common dbt operations, you can simply click the **Preview** or **Build** buttons to preview or build the whole project directly without using command-line tools.
## Next Steps
AI-powered dbt assistant with full lineage context.
Set up your dbt project to use with the AI Terminal.
Configure environment variables for your dbt profiles.
# SQL Projects
Source: https://docs.tensorstax.com/sql-projects
Create and manage SQL projects with TensorStax
## Overview
Docs coming soon
