StackAI is an enterprise platform for building and deploying AI agents, with a strong focus on governance and security.

IT and Operations teams utilize StackAI to deploy internal applications that enhance and automate business processes, ranging from the simplest use cases, such as chatbots that retrieve information from databases like Microsoft SharePoint, to the most sophisticated automations, including performing in-depth research to generate investment memos.

StackAI's powerful orchestration engine and extensive integrations simplify and accelerate the automation of business processes. We provide the observability and controls necessary to deploy AI Agents across your organization. That is why banks, defense companies, and governments trust us to accelerate their transition to an AI-first organization and streamline their productivity.

End-to-End Experience

StackAI offers an end-to-end experience, allowing users to build both the logic of the AI agent using a drag-and-drop workflow builder and the interface of the AI agent by selecting pre-built user interfaces. Once the AI Agent is configured, it can be deployed and monitored with a few clicks.

AI Pipeline & Integrations

All components to build an AI application are available in StackAI with different levels of abstraction to help both non-technical and technical teams. The entire data pipeline needed for deploying AI applications can be configured in just a few steps.

From document indexing to retrieval, users can build Retrieval Augmented Generation (RAG) systems by simply dragging a “Knowledge Base” node into their workflow, with default settings optimized for 90% of the use cases. This significantly streamlines the development of AI applications for both non-technical and technical users (i.e., IT teams new to AI development).

Function calling, implemented through the concept of “Tools,” is equally intuitive. Users only need to select the desired tools at the LLM level; no code or complex setup required.

StackAI also offers a wide range of integrations with both established systems (such as SharePoint, SAP, Workday, Salesforce, etc) as well as modern SaaS companies (like Exa AI, Snowflake, and Miro), making data ingestion seamless and efficient.

Implementation Support

StackAI provides the platform and forward-deployment engineers to help customers build complex use cases and deploy those with confidence. Given the pace of innovation in AI, we offer the necessary guidance both with AI strategy as well as with tactical development advice, from testing new AI models to experimenting with different agentic architectures.

StackAI supports all enterprise customers with weekly co-building sessions led by forward-deployed engineers, GenAI-focused hackathons (also known as Stackathons), and Quarterly Business Review (QBR) sessions to align on progress and roadmap priorities.

AI Governance

StackAI is SOC 2 Type II, HIPAA, and GDPR compliant, with ISO 27001 certification in progress. For organizations with strict data residency or sovereignty requirements, StackAI offers On-Premise deployment options, critical for industries like defense and finance. This capability sets us apart from most providers; since they force customers to use their cloud solution.

Granular Role-Based Access Control (RBAC) enables admins to precisely govern who can modify and interact with LLMs, edit Knowledge Bases, or publish Workflows. Every component, from interfaces to citations, can be secured, authenticated (e.g. via SSO), and production-locked to ensure transparent accountability and control.

Admins can enforce approval flows, protect production environments from accidental edits, and ensure only reviewed agents are launched, with version control of all changes. Furthermore, Admins receive notifications of the status of their agents in production in real-time.

StackAI's on-premise deployment offers enterprise-grade control, performance, and security by running entirely within your organization's infrastructure. This allows customers to have full control over their data, and deploy local LLMs that can be orchestrated in StackAI, resulting in fully controlled AI applications.

Our on-premise deployment includes Single Sign-On (SSO), and can be deployed in most cloud providers (including AWS, GCP, and Azure) or in your organization's servers.

Projects Dashboard

Let's start by creating a new project in Stack AI dashboard. Click on the "New Project" button in the top right corner of the dashboard.

Templates

Create a Quick Start project to open a blank project, or browse through a list of pre-built templates. You can choose the "Chat with Knowledge Base" template to build an application where your users can ask questions on a knowledge base you've uploaded.

You can search for a specific application you would like to integrate with a Large Language Model, like "Gmail," or you can look through the list of use cases on the left side of the screen.

Workflow View

Once you create a project, you will see an interface with 3 main components:

Workflow View

• Canvas: the main component of the Stack AI tool, a 2D canvas where you can drag and drop nodes and connect them to build your workflow.

• Sidebar: a large variety of functionality blocks, also called nodes, can be found on the left hand side. These nodes represent components in the flow where data is received, processed, and returned from different services. Chat with Workflow on the bottom of the sidebar for advice on how to build or to learn about what an existing project does.

• Control bar: a set of commands at the top right hand side with buttons to 'Save' (save the current version), 'Run' (execute the workflow as it is in the canvas), 'Share' (share the current version with another Stack AI user), and 'Publish' (make your workflow available externally).

The Workflow View is where you can build your project, by dragging and connecting the necessary nodes to create your agent. Once you are ready to deploy your agent to users, hit 'Publish' in the top right corner. If its your first time publishing your project, you will be prompted to enter the Export View to choose an interface for your agent.

Other Important Views

Export View

By clicking the 'Export' button in the top left side bar, you will see a view with different interface options.

We offer pre-built interfaces for your AI chatbots that can be easily customized to match your brand's look and feel.

You can choose from a ChatGPT-style interface, a website chatbot, a voice interface, or deploy your chatbot via Slack, WhatsApp, or SMS. We offer the option to use Stack AI as a backend process, leveraging our APIs to send inputs, receive results, and build your own custom UI.

You will find different customization options in the Export tab (name, logo, colors, etc.). Configure a custom domain if required and protect your chatbot with SSO or password.

An URL is generated for you to share with your colleagues.

IMPORTANT: whenever you make changes to your project in the Builder View, always remember to click the Publish button. This will update the assistant's user interface.

Analytics View

Clicking on the 'Analytics' button in the top left sidebar will display a summary of your workflow usage.

This page features four graphs that provide an overview of workflow utilization, along with a complete list of execution logs. The logs include valuable information such as the execution status, runtime, tokens consumed, and the workflow's inputs and outputs. Additionally, you can filter the analytics by date using the selector in the top left corner.

Manager View

Clicking the 'Manager' button in the top left sidebar will take you to a view with all user conversations with your workflow. To download all conversations, click the "Download" button. To clear the conversation history, click "Delete".

Evaluator View

Click 'Evaluator' to enter the Evaluator View. This view allows you to test your agent on a batch of inputs uploaded in a CSV file. You can have the output be graded by another LLM, who will judge whether your agent outputs desirable results. You can also have the LLM compare the output of your agent to a gold standard answer, or make suggestions. Just edit the prompt on the right side of the screen.

StackAI prioritizes data protection and compliance, making it suitable for industries with stringent regulatory requirements. Key security features include:

• Compliance Certifications: Adherence to SOC 2 Type II, HIPAA, and GDPR standards ensures that data handling meets global regulatory requirements.

• Guardrails: LLMs can deviate from their initial requirements by answering questions they were not prompted to answer. Guardrails allow our customers to ensure LLMs do not answer questions and topics they are not supposed to reply.

• PII Protection: Built-in mechanisms detect and mask Personally Identifiable Information (PII), safeguarding sensitive data during processing.

:

• Data Retention Policies: Organizations can define data retention durations, ensuring data is stored only as long as necessary.

• No Data Training: StackAI ensures that user data is not used to train AI models as part of its enterprise agreements with providers, maintaining data confidentiality.

Multi-Factor Authentication

To turn on MFA, go to Settings -> Feature Access -> Authentication. Click manage and turn on MFA. This will apply to all users in your organization.

What is Generative AI?

Generative AI refers to a type of artificial intelligence that is capable of generating content. It involves the use of models trained to generate new data that mimic the distribution of the training data. Generative AI can create a wide array of content, including but not limited to text, images, music, and even synthetic voices.

What is an LLM?

LLM stands for Large Language Model. These models, such as GPT-4, are a type of artificial intelligence model that uses machine learning to produce human-like text. Large Language Models are trained on vast amounts of text data and can generate sentences by predicting the likelihood of a word given the previous words used in the text. They can be fine-tuned for a variety of tasks, including translation, question-answering, and writing assistance. These models are called "large" because they have a huge number of parameters. For example, GPT-4, one of the largest models as of today, has about 1.8 trillion adjustable parameters. Their large parameter count allows these models to capture a wide range of language patterns and nuances, but also makes them computationally expensive to train and use.

What type of applications can I build with Generative AI?

Generative AI models have a wide range of potential applications across numerous fields. Here are some examples:

1. Content Creation: These models can generate new pieces of text, music, or artwork. For example, AI could create music for a video game, generate a script for a movie, or produce articles or reports.

2. Chatbots and Virtual Assistants: Generative models can be used to create conversational agents that can carry on a dialogue with users, generating responses to user queries in a natural, human-like manner.

3. Image Generation and Editing: Generative Adversarial Networks (GANs) can generate realistic images, design graphics, or even modify existing images in significant ways, such as changing day to night or generating a person's image in the style of a specific artist.

4. Product Design: AI can be used to generate new product designs or modify existing ones, potentially speeding up the design process and introducing new possibilities that human designers might not consider.

5. Medical Applications: Generative AI can be used to create synthetic medical data, simulate patient conditions, or predict the development of diseases.

6. Personalized Recommendations: AI models can generate personalized content or product recommendations based on user data.

7. Data Augmentation: In situations where data is scarce, generative models can be used to create synthetic data to supplement real data for training other machine learning models.

What is an embedding?

Embeddings are numerical representations of concepts converted to number sequences, which make it easy for computers to understand the relationships between those concepts. They are capable of capturing the context of a word in a document, its semantic and syntactic similarity, and its relation with other words.

What is a vector store?

A vector store in the context of machine learning is a storage system or database designed to handle vector data efficiently. Vector data is commonly used in fields like natural language processing and computer vision, where high-dimensional vectors are used to represent complex data like words, sentences, or images. Vectors stores are often optimized for operations that are common in machine learning, like nearest neighbor search, which involves finding the vectors in the store that are closest to a given vector. This is particularly useful in tasks like recommendation systems, where you might want to find the items that are most similar to a given item.

What is a multimodal model?

A multimodal model in the field of artificial intelligence is a model that can handle and integrate data from multiple different modalities, or types, of input. These types of inputs can include text, images, audio, video, and more. The main advantage of multimodal models is that they can leverage the strengths of different data types to make better predictions. For example, a model that takes both text and image data as input might be able to understand the context better than a model that only uses one or the other.

What is the memory of an LLM?

A Large Language Model (LLM) can generate text based on what it has seen before if it has memory. The term "memory" in this context refers to how much of the previous text the model can consider when producing new text. Memory is a different concept than the training set used to train the model. The model can answer things from what it knows given the training set that is was given. Additionally, considering that you are chatting with chatGPT, the model will respond to your queries considering the last responses and queries as well. This "memory" of the model is indeed crucial when dealing with long pieces of text or conversations, as it determines how much of the previous context the model can use to generate accurate and coherent responses.

The Audio Node allows you to upload or record an audio clip as input. The audio is converted to text (using an audio-to-text LLM) and passed to your model.

Providers

The Audio Node enables you to choose from two providers that will transcribe your audio:

• deepgram: Uses Deepgram's API for audio transcription. Supports multiple models and submodels.

• whisper-1: Uses OpenAI's Whisper v1 model. Does not support model or submodel selection (uses a default configuration).

Model

Available only when using the deepgram provider. Defines the main model used for transcription.

• nova: Legacy model, fast and lightweight.

• nova-2: Latest generation with improved accuracy and speed.

• enhanced: Optimized for high-quality audio and complex content.

• base: Baseline transcription model with balanced performance.

This field is disabled for whisper-1.

Submodel

Further refines transcription behavior. Available only with deepgram.

• general: Default submodel for general-purpose transcription.

• Other submodels exist depending on Deepgram's model.

This field is disabled for whisper-1.

Audio Node Settings

If you're using your own audio-to-text model, here you can add your own API key to use it.

How to use it

1. Add an Audio to Text node to your flow.

2. Connect the Audio to Text node to an LLM node.

3. Mention the Audio to Text node in the LLM node by pressing "/" and selecting the Audio to Text node.

4. Add an Output node to your flow.

5. Connect the Output node to the LLM node.

Expose the Audio to Text node to your users

1. Go to the Export tab.

2. Enable the audio node in the Inputs section.

3. Press Save Interface to save your changes.

4. Your users should now see an upload button in the interface.

What is an Output Node?

An Output node displays the results generated by other nodes in your workflow. It acts as the final delivery point in your data pipeline, where outputs from processing nodes (like LLMs or data processors) are shown to your users.

The Output node is typically connected to nodes that generate textual or structured responses, such as:

1. LLM nodes (to display answers or messages).

2. Knowledge Base nodes (to show retrieved documents or summaries).

Key benefits of the Output node:

• Provides a clear way to present results to end-users.

• Enables visibility into the results of data transformations or AI completions.

• Supports dynamic interfaces when exposed via the Export tab.

How to expose Outputs externally?

To allow users to see the Output node results:

1. Go to the Export tab.

2. Enable the Output node in the Outputs section under Fields.

3. Click Save Interface.

4. The Output node’s results will now appear in your external interface when the workflow is triggered.

What to expose in the Output node?

With the Output node, you will be able to plot the result coming out of any other node.

Here are a few quick facts:

• Markdown: The output node uses Markdown to format the text. You can use it to add links, imgs, headings, and more.

• Length: While output can have any length, you should be mindful that LLM prompts have a limit on how many words they can result.

• Intermediate Outputs: Use intermediate Output nodes to debug your workflow: for example, connect it to a vector store to see what chunks of text are returned.

What is an Action Node?

An Action node allows your workflow to interact with external systems. You can use it to send data to other apps, update databases, trigger web searches, or automate other tasks across services.

This node is typically used after collecting and processing data through Input or LLM nodes.

Common uses include:

• Sending rows to Airtable or Excel

• Updating documents in Notion or MongoDB

• Querying or writing to PostgreSQL

• Triggering a Web Search and retrieving results

• Sending Emails using Gmail or Outlook

These nodes help turn your workflows into automated agents that don’t just compute — they also take action.

How to use the Action node

To use the Action node:

1. Click the node.

2. In the right panel, search and select an action from the desired node.

Depending on the Action selected:

• Input: Requires structured data (usually JSON or plain text) from a previous node.

• Output: Sends data to an external service. The result can optionally be passed to an Output node or another processing node like an LLM.

Not all actions produce user-facing output. Some simply perform the task in the background — such as logging, sending an email, or updating a database.

What is an Audio Node?

The Audio node lets you generate audio from text using high-quality voice synthesis models. It's ideal for turning responses from LLMs or static text into spoken audio.

This node is commonly used in voice interfaces, accessibility workflows, or any experience where you want to deliver output via sound.

It supports popular text-to-speech engines and customizable voices to match your tone and use case.

Key capabilities include:

• Supports multilingual audio synthesis.

• Choose from multiple voice models and accents.

• Play back audio directly in the interface with Test Output.

• Optionally use your own API key to connect with external TTS providers.

How to use it?

To use the Audio node:

• Input: Accepts a text string (e.g., from an LLM or Input node).

• Output: Returns a playable audio file that can be previewed that can be previewed.

After receiving text input, the Audio node displays a Test Output section with a play button, allowing you to listen to the generated audio.

Settings

Configuration Options

• Model: Choose the TTS engine, such as eleven_multilingual_v2.

• Voice: Select from available voice profiles (e.g., Sarah, Chris).

• API Key: Optional field for providing your own TTS provider credentials.

How to expose Audio externally?

To make audio results available in your external interface:

1. Go to the Export tab.

2. Enable the Audio node in the Outputs section under Fields.

3. Click Save Interface.

4. When triggered, users will be able to hear the generated audio directly in the interface.

Microsoft Azure and AWS Bedrock offer the ability to host private clouds with OpenAI models. You can add these models in Stack AI using an "Azure" node or "Bedrock" node. Hosting models in Azure/Bedrock has benefits:

Azure

1. Lower and Consistent Latency: Cloud hosted models are not affected by public API traffic. This is a great option if latency is a real concern.

2. Higher Rate Limits: Models in Azure offer higher rate limits of up to 240,000 tokens per minute and 1440 requests per minute.

3. Data Privacy and Compliance: data sent to Azure is kept under the private cloud and is not sent to OpenAI or any external service. These models are covered under Azure's Business Associate Agreement (BAA) and are HIPPA compliant.

AWS Bedrock

1. AWS Security & Compliance: Bedrock leverages AWS’s security, IAM, and compliance features. You can use AWS IAM roles, VPC endpoints, and audit logging for enterprise-grade security.

2. Data Privacy & Residency: Data processed through Bedrock stays within AWS infrastructure. You can choose the AWS region for data residency requirements.

How It Works

Microsoft Azure

• Azure OpenAI Service: Azure provides access to OpenAI models (like GPT-3.5, GPT-4, etc.) through its Azure OpenAI Service.

• How it works: You provision an Azure OpenAI resource, get an endpoint and API key, and can then use these credentials to access models via Azure’s API.

AWS Bedrock

• Amazon Bedrock: AWS offers access to multiple foundation models (including Anthropic Claude, AI21, Cohere, and Amazon’s own Titan models) through the Amazon Bedrock service.

• How it works: You provision an AWS Bedrock resource, get an endpoint and API key, and can then use these credentials to access the models you have enabled via AWS's API.

Here you will Learn how to build, deploy, and manage secure AI agents using StackAI, the orchestration platform built for modern teams. This Academy is designed for anyone using StackAI.

In this series, you’ll explore everything from connecting data and building workflows to customizing interfaces and applying advanced logic, all without needing to reinvent the wheel.

▶️ Start learning below.

Video modules include:

1. Platform Overview

2. Building Your First Workflow

3. Agent Builder

4. Deep Dive into UI

5. Connecting your Data to an AI Agent

6. Agentic Tools

7. Using LLMs

8. Logic Nodes

9. Developer Capabilities

10. Apps & Integrations

11. Governance

12. Handling Data

🔗 Try StackAI: https://stack-ai.com

A LLM Node is the heartbeat (or heartbeats!) or your project. StackAI is provider-agnostic, just choose your favorite provider and select the model you'd like to use in your project. If you change your mind and want to try a different provider or model, just make your selection in the dropdown menu.

To see an up to date list of our available providers and models, visit our LLM Leaderboard here.

To manage AI deployments effectively, StackAI offers governance features like:

• Role-Based Access Control (RBAC): Define user permissions at granular levels, including access to the knowledge base and connections.

• Single Sign-On (SSO): Integrate with identity providers like Okta and Entra ID for user authentication and inheritance of groups and permissions.

• Project Publishing Controls: Restrict project publishing capabilities to authorized personnel, ensuring oversight.

• Centralized Monitoring: A unified dashboard allows administrators to monitor agent activities, usage metrics, and error logs in real-time.

Below is a comprehensive guide to StackAI’s governance model, designed for teams that need speed without losing control.

The StackAI Governance Model (8 Layers)

1) Role-Based Access Control (RBAC) and Groups

Admins can create groups (e.g., “Legal,” “HR,” “Capture Team”) and assign them to workspaces/projects for coarse-grained control.

2) Workspace and Folder Access (Scope Control)

Easily create private group folders with specific allowlists. Only assigned users or groups can see what’s inside—others see nothing.

Easily view project owners and editors as well, by hovering over a project or in a list view.

3) Project Controls (Edit, Lock, Versioning)

Creators can lock a project (only the owner edits; admins can override).

All changes made to projects can be tracked with version control and diffs, so you can see exactly who changed what and when, and roll back. You can easily see all previously published versions of a project; and versions can be tagged with a commit message to clarify what changes were made. Easily go back to a previous version if desired.

4) Interface-Level Security (How You Publish)

When you export an agent (advanced form, chatbot, Slackbot, etc.), you can:

• Enable one-click SSO on the interface editor

• Set a password for external collaborators.

• Restrict by allowed origins/URLs and even a user allowlist.

5) Global Governance and Admin Policy (Feature Access and Guardrails)

Org admins can set cross-cutting policy:

• Require SSO on all interfaces.

• Restrict who can publish, so that non-admins don't publish projects.

• Enable an approval/feature-flag workflow for changes, wherein users request for their project to be reviewed and published by admin.

• Allow/deny specific tools, connectors, and more through Feature Access (e.g., block Notion/Box across the org).

• Set usage limits (e.g., token caps) as a security throttle.

• Assigning user roles.

• Disabling LLMs and adding default connections (i.e., your company’s API keys).

You can also build policy by group (e.g., “only Legal can access the Legal agents”).

6) Connection and Knowledge-Base Permissions

Connections (SharePoint, Dropbox, ServiceNow, etc.) are owned by their creator, with private details and credentials encrypted and hidden from others. Owners and admins can share a connection org-wide or limit it to specific users or groups.

Knowledge bases support the same allowlisting, so only authorized teams can reference sensitive content.

7) Production Analytics and Auditing

Downloadable project analytics show who ran what, when, with which models, token counts, latency, and per-step traces (inputs, KB hits, outputs). Builders can mask or disable logs when required, or limit visibility to the owner. For certain cases of external security tooling, StackAI can deliver scheduled exports and can post to a customer webhook (e.g., daily digests) for alerting pipelines.

Below are some of the most widely used governance features, developed in close collaboration with our customers:

Learn more about Analytics .

8) Authentication and MFA

Organizations can use email/password (when enabled) or SSO (recommended). Enabling SSO means protecting any or all interfaces from access by members outside of your organization; further, SSO allows you to capture the email addresses of all users of your interfaces to easily keep track of who is using your workflows. You can also require SSO for all interfaces. By default, SSO users land as users until granted higher roles.

An Input Node allows you and your end-users to send text queries to any node that accepts text strings as input.

The most popular nodes accepting inputs are:

1. The LLM nodes (adding the input as part of their prompt).

2. The Knowledge Base nodes (they use the input as a prompt to retrieve information from their contents)

Here are a few quick facts:

• Inputs can be text fields of any length and are passed to their connected node in the flow.

• While inputs can be of any length, you should be mindful that LLM prompts have a limit on how long of an input they can process. To handle long inputs, consider using the Text Data Loader.

• To expose an Input node to your users, you will need to set it up in the Export tab.

Exposing Inputs Externally

If you'd like an input to be automatically populated when the user open's your agent's interface, you can expose inputs externally. This is useful in cases where you automatically want to capture the user's id or other metadata about the user, like their timezone. To do this, first publish your project and head to the Export View. for detailed instructions.

What is a URL Node?

The URL Node allows users to add a URL to the flow and scrape the HTML or Metadata of a website to use as an input to the LLM. If an LLM node returns a URL as its output, it can feed into the URL node to scrape a website in a more complex workflow. The entire output of the URL Node will be given to the LLM as context.

Mode

Defines what type of content to fetch from the provided URL.

• Page HTML: Downloads the full HTML content of the page. Suitable for use cases like content parsing, summarization, or extraction of visible page elements.

• Metadata only: Fetches only metadata (e.g., <title>, <meta> tags such as description and Open Graph data). Useful for lightweight previews or indexing.

Scrape Subpages

When enabled, the node will attempt to crawl and include linked subpages within the same domain.

Enable URL as Input

When checked, this enables dynamic input of URLs via upstream nodes or user input, rather than hardcoding a static value in the interface.

How to use the URL Node

1. Add a URL node to your flow.

2. Connect the URL node to an LLM node.

3. Mention the URL node in the LLM node by pressing "/" and selecting the URL node.

4. Add an Output node to your flow.

5. Connect the Output node to the LLM node.

URL Node Settings

If you click the gear icon in the node, you will see the available settings.

Chunking Settings

• Chunking Algorithm: Defines how the data is split (e.g., Sentence-based).

• Chunk Overlap: The number of overlapping tokens between chunks.

• Chunk Length: Max length of each chunk sent to the LLM.

Additional Features

• Advanced Data Extraction: Enable more precise field-level parsing (toggle option).

• Text in Images (OCR): Extract and include text from profile images or banners (toggle option)

What is a Knowledge Base?

A knowledge base is a centralized repository of information, documents, or data that can be searched and referenced to answer questions, solve problems, or provide context.

StackAI enables users to leverage a powerful and flexible RAG (Retrieval-Augmented Generation) system through a simple drag-and-drop interface. By connecting directly to their knowledge base, users can effortlessly incorporate contextual search capabilities.

To use a Knowledge Base in your project, drag and drop a Knowledge Base Node or select the Knowledge Base tool in your LLM. Knowledge Bases can be created and managed in the Knowledge Base Dashboard, or you can create one on the fly in your Knowledge Base Node.

The standalone Knowledge Base Node requires an input to function—usually a standard text input. This input serves as the query that the Knowledge Base uses to fetch relevant context. If there are multiple inputs connected, you can specify which one to use in the Knowledge Base settings.

The Knowledge Base Node

The Knowledge Base node acts like a search engine over files, allowing LLMs to retrieve the precise context needed to perform any given task effectively. Indexing and storage in vector databases happen automatically, without any action from the user. Syncing also occurs automatically, if enabled, so that new files or changes are added to the knowledge base.

Unlike other platforms, StackAI enables users to leverage a powerful and flexible RAG (Retrieval-Augmented Generation) system through a simple drag-and-drop interface. By connecting directly to their knowledge base, users can effortlessly incorporate contextual search capabilities. The Knowledge Base node acts like a search engine over files, allowing LLMs to retrieve the precise context needed to perform any given task effectively. Indexing and storage in vector databases happen without any action from the user. Syncing occurs automatically if enabled, so that new files or changes are added to the knowledge base.

Import Knowledge From Any Source

StackAI allows you to create a knowledge base from uploaded documents, tables, Dropbox, Google Drive, Sharepoint, and many more! File metadata from platforms like SharePoint is also imported to enhance information retrieval, resulting in a 27% increase in accuracy for financial applications.

Advanced search controls within the knowledge base, designed with the right level of abstraction to ensure ease of use for end users.

Citations are clearly displayed in the user interface to enable response auditing. Users can view the original source file and the exact information chunks utilized by the LLM. Superscript references within the response allow users to easily trace and verify the underlying data.

The Azure SQL Node is a workflow node that allows you to query an Azure SQL database using either plain English or SQL queries. This node is ideal for retrieving, analyzing, and interacting with your database data directly within your workflow, making data access seamless and user-friendly.

How to use it?

To use the Azure SQL node, you must provide two required inputs:

1. Schema: Describe your database schema, including tables, columns, and data types.

2. Query: Enter your question or request in plain English or as a SQL statement.

The node will process your input, convert plain English queries to SQL if needed, execute the query, and return the results.

Example of Usage

Suppose you have a table called Sales with columns CustomerName, OrderAmount, and OrderDate.

• Schema (Required):

• Query (Required):

  or

Outputs:

• Query (Required): The SQL query that was executed (e.g., SELECT SUM(OrderAmount) FROM Sales WHERE YEAR(OrderDate) = 2024;)

• Results (Required): The results of the query (e.g., {"SUM(OrderAmount)": 150000})

Available Actions

• Query an Azure SQL database

  • Inputs:

    • Schema (Required): The structure of your database (tables, columns, types, etc.).

    • Query (Required): Your question in plain English or a SQL statement.

  • Configurations: None required beyond the schema and query.

  • Outputs:

    • Query: The SQL query that was executed.

    • Results: The results returned from the database.

Instruction vs Prompt (System Prompt vs User Prompt)

In the world of Large Language Models (LLMs), understanding the difference between "Instruction" and "Prompt" (often referred to as "System Prompt" and "User Prompt") is key to getting the best results. It's not just about what you ask, but how you set up the AI's overall behavior and then provide specific tasks.

The System Prompt: The AI's Job Description Think of the System Prompt as the AI's "job description" or its persistent identity. It's a high-level, foundational set of instructions that defines the AI's core behavior, its persona, and any rules it should always follow throughout an entire conversation or session.

What goes in a System Prompt?

• Role Prompting: This sets the AI's persona, like "You are a seasoned data scientist" or "You are a helpful and informative AI assistant specializing in technology." This helps the AI interpret all subsequent requests through that specific lens.

• Ethical Guidance and Constraints: This is where you establish non-negotiable rules, such as avoiding certain topics ("Avoid discussing political opinions") or refusing harmful requests.

• Defining Scope: You can specify the areas of expertise the AI should draw from and what's out of bounds.

• Tool-Use Instructions: For more advanced applications, you can define what external tools the AI has access to and when it should use them.

The System Prompt is stable and typically remains consistent across many interactions, providing a steady framework for the AI's operation.

The User Prompt: The Task-Specific Request In contrast, the User Prompt is dynamic and task-oriented. It contains the specific question, command, or data for a single interaction within the conversation. It's the immediate "what" you want the AI to do right now.

What goes in a User Prompt?

• Specific Questions and Commands: This is where you put your direct query, like "What are some eco-friendly travel destinations in South America?" or "Translate this text to French."

• Task-Specific Context: Any details relevant only to the current turn of the conversation, such as "I'm planning a trip in June and prefer destinations with hikes."

• Few-Shot Examples: If you need to show the AI examples of input-output pairs for a specific task, these are best placed in the User Prompt.

• Response Formatting Instructions: While general style can be in the System Prompt, specific output formats for a single response (e.g., "Please provide the information in a list format," or "Answer in JSON format") are often more effective here.

Why the Separation Matters This deliberate separation into System and User prompts is a critical architectural choice for building robust and scalable LLM applications.

• Clarity and Maintainability: Separating concerns makes your prompts easier to read, debug, and update. Your core AI configuration (system prompt) is distinct from the varying user inputs.

• Optimized Model Performance: LLMs are often specifically trained to handle these distinct roles. Adhering to this structure is believed to provide a performance benefit, leading to more accurate and reliable outputs.

• Future-Proofing: As your application evolves, having a modular prompt structure allows for easier modifications and additions of new features without overhauling your entire prompting logic.

By understanding and effectively using both system and user prompts, you can better control LLMs, making your applications more predictable, reliable, and powerful for various tasks.

What is an Image Node?

The Image node allows you to generate visual content from text prompts using AI image generation models such as OpenAI’s DALL·E 3 or Stable Diffusion.

Use this node to turn descriptions into visuals. Ideal for creative tools, content generation, or enhancing user engagement with dynamic imagery.

Common applications include:

• Illustrating chatbot responses

• Creating product mockups or concept art

• Generating visual assets on-the-fly for user interfaces

How to use it?

To use the Image node:

• Input: Accepts a text string (prompt), often from a user or LLM node.

• Output: Returns a generated image that can be previewed or used downstream.

The model processes the prompt and returns a generated image in the specified size and style.

Settings

Configuration Options

• Model: Choose between available image generation models:

  • OpenAI DALL·E 3

  • Stable Diffusion 3.5

• Image size: Select the resolution for the generated image:

  • 1024×1024 (square)

  • 1024×1792 (portrait)

  • 1792×1024 (landscape)

• API Key: (Optional) Provide your own key to use a custom instance or higher tier of the selected model.

By adjusting the model and size, you can tailor visual outputs to match your product’s design or artistic needs.

How to expose Images externally?

To allow users to see the generated images:

1. Go to the Export tab.

2. Enable the Image node in the Outputs section under Fields.

3. Click Save Interface.

4. The image result will now be rendered in your external interface when the flow is triggered.

This guide offers various strategies and techniques to improve the performance of your Language Model (LLM). You can experiment with these methods individually or in combination to achieve better results for your specific needs. Some strategies include:

1. Write Clear Instructions

Ensure that your instructions are concise and clear. If the outputs are too lengthy, request brief responses. If you need expert-level writing, specify that. Minimizing guesswork for the LLM increases the likelihood of receiving the desired output. Consider the following:

• Include specific details in your query for more relevant answers.

• Instruct the model to adopt a specific persona.

• Use delimiters to indicate distinct parts of the input.

• Specify the steps required to complete a task.

• Provide examples.

• Specify the desired length of the output.

• Refer to the Evaluation Description of available LLMs.

2. Provide Reference Text

To reduce the generation of fake answers, particularly on obscure topics, or to include citations and URLs, provide reference text that can assist the LLM. Here's what you can do:

• Instruct the model to answer using reference text.

• Instruct the model to answer with citations from reference text.

• Refer to Offline Data Loaders.

3. Break Down Complex Tasks into Simpler Subtasks

Complex tasks tend to have higher error rates. To enhance performance, break down complex tasks into simpler subtasks. You can:

• Use intent classification to identify the most relevant instructions for a user query.

• For dialogue applications with long conversations, summarize or filter previous dialogue.

• Summarize long documents piecewise and construct a full summary recursively.

• Refer to the Description of available LLMs.

4. Allow LLMs Time to "Think"

LLMs may make more reasoning errors when rushed. Asking for a chain of reasoning before a response can help them reason their way to correct answers. Consider:

• Instructing the model to work out its solution before rushing to a conclusion.

• Using an inner monologue or a sequence of queries to hide the model's reasoning process.

• Asking the model if it missed anything on previous passes.

• Refer to the Description of available LLMs.

5. Utilize External Tools

Compensate for LLM weaknesses by using outputs from other tools. Text retrieval systems or code execution engines can be helpful. If a task can be done more reliably or efficiently with a tool, consider using it for better results:

• Use embeddings-based search for efficient knowledge retrieval.

• Use code execution for more accurate calculations or call external APIs.

• Refer to Offline Data Loaders.

6. Test Changes Systematically

Measuring the impact of changes is essential for improvement. Define a comprehensive test suite (eval) to ensure that modifications yield a net positive performance:

• Evaluate model outputs with gold-standard answers.

• Refer to Evaluation.

Each of the strategies listed above can be implemented with specific tactics. These tactics provide ideas for experimentation and improvement. Feel free to explore creative ideas beyond what's listed here.

The Knowledge Base Node in StackAI allows you to search and retrieve information from your indexed documents. It is designed to help AI workflows access relevant content from your organization's knowledge repositories, making it easy to build intelligent document search, retrieval-augmented generation (RAG), and automated Q&A solutions.

How to use it?

To use the Knowledge Base node, connect it within your StackAI workflow where you want to enable document search or retrieval. The node can be configured to search specific knowledge bases, filter results, and control the number and type of results returned. It is typically used in conjunction with LLM nodes to provide context-aware answers or summaries based on your indexed content.

Example of Usage

Suppose you want to build a chatbot that answers user questions using your company’s internal documentation. You would add the Knowledge Base node to your workflow, configure it to search your indexed documents, and connect its output to an LLM node. When a user asks a question, the Knowledge Base node retrieves relevant document snippets, which the LLM then uses to generate a precise answer.

Available Actions

Below are the most commonly used actions for the Knowledge Base node:

1. Search Knowledge Base

Description: Searches your indexed knowledge base for relevant documents or content based on a query.

Inputs:

• query (Required): The search string or question to look up in your knowledge base.

• knowledge_base_id (Required): The unique identifier of the knowledge base to search.

• filters (Optional): Metadata or tag filters to narrow down the search results.

• top_k (Optional): The maximum number of results to return (default is 10).

• advanced_rag (Optional): Boolean to enable advanced retrieval-augmented generation features.

Configurations:

• connection_id (Required if your knowledge base requires authentication): The connection ID for accessing the knowledge base provider.

Outputs:

• results (Required): An array of relevant document snippets or content chunks.

• metadata (Optional): Additional information about each result, such as source, date, or tags.

Example:

• Input:

  • query: "What is the company’s refund policy?"

  • knowledge_base_id: "630eed87-31bf-4e64-9399-a1d298ca8a45"

  • top_k: 5

• Output:

  • results:

    • "Our refund policy allows returns within 30 days of purchase..."

    • "Refunds are processed within 5 business days after approval..."

How to Use in a Workflow

1. Add the Knowledge Base node to your StackAI workflow.

2. Set the required inputs, such as the query and knowledge base ID.

3. (Optional) Add filters or adjust the number of results.

4. Connect the output to an LLM node or Output node to display or process the retrieved information.

Best Practices

• Always specify the correct knowledge base ID to ensure accurate search results.

• Use filters to refine results for more targeted answers.

• Combine with LLM nodes for context-aware, natural language responses.

Summary

The Knowledge Base node is a powerful tool in StackAI for searching and retrieving information from your indexed documents. By configuring its inputs and outputs, you can build intelligent workflows that leverage your organization’s knowledge for automation, support, and more.

What is Loom?

Loom is a video messaging tool that enables users to create, share, and manage videos quickly and efficiently. Integrating Loom with StackAI allows you to automate video-related tasks, such as transcribing videos, extracting insights, or managing video content, directly within your workflows.

Example of Usage

Suppose you want to automatically transcribe a Loom video and use the transcript in a report. You can set up a workflow where the Loom node retrieves the video transcript, which is then processed by an LLM node and formatted for output.

Available Actions

1. Loom Transcript

Description: Retrieve the transcript of a Loom video for further processing or analysis.

Inputs:

• video_url (Required): The URL of the Loom video you want to transcribe. Example: "https://www.loom.com/share/your-video-id"

Configurations:

• No additional configurations are required for this action.

Outputs:

• transcript (Always returned): The full text transcript of the Loom video. Example:

  Copy

  "Welcome to our product demo. In this video, we will walk through the main features..."

How to Use in a Workflow:

1. Add the Loom node to your StackAI workflow.

2. Select the "Loom Transcript" action.

3. Enter the Loom video URL as the required input.

4. Connect the output to downstream nodes (e.g., LLM, Template, Output) for further processing.

Summary Table

What is Notion?

Notion is a collaborative workspace that helps you organize, manage, and share information. With StackAI, you can automate the creation of Notion pages directly from your workflows, making it easy to generate structured content and knowledge bases.

How to use it?

The Notion node in StackAI allows you to create new pages in your Notion workspace. You must provide the parent page, a title, and the content for the new page. This node is ideal for automating documentation, meeting notes, or any structured data entry into Notion.

Example of Usage

Suppose you want to automatically create a project summary page in Notion after a workflow completes. You would use the Notion node to send the project details as a new page under a specific parent page.

Available Actions

1. Create Page

Create a new page in your Notion workspace under a specified parent page.

Inputs (All Required):

• Parent Page (parent_page_id): Select the parent page under which the new page will be created. Example: "d695667e-33c4-4b9d-9f93-8c01ec1d7b89"

• Title (title): The title of the new Notion page. Example: "Weekly Project Update"

• Content (content): The main content to be written as text blocks in the new page. Example: "This week, we completed the following milestones..."

Configurations: No additional configurations are required beyond the inputs above.

Outputs (All Always Provided):

• Page ID (page_id): The unique identifier of the newly created Notion page. Example: "b1a2c3d4e5f6g7h8i9j0"

• Page URL (page_url): The direct URL to access the new Notion page. Example: "https://www.notion.so/yourworkspace/b1a2c3d4e5f6g7h8i9j0"

• Message (message): A status message indicating the result of the operation. Example: "Page created successfully."

Example of Usage

You want to automate meeting notes creation:

• Set the Parent Page to your "Meetings" section.

• Set the Title to "Team Sync - July 8, 2025".

• Set the Content to the meeting summary generated by an LLM node.

After execution, the Notion node will return the new page's ID, URL, and a success message, allowing you to share or reference the page in further workflow steps.

The Pinecone Node allows you to search a Pinecone vector database for vectors that are most similar to a given text input. It returns a list of similar vectors along with their metadata.

Required Inputs for the Pinecone Node

To use the Pinecone node, you need to provide the following input parameters:

1. Query (string, required): The text you want to search for similar vectors. For example, "AI marketing trends".

2. Number of Results (top_k) (integer, required): How many similar vectors you want to retrieve. The default is 5.

3. Index Name (string, required): The name of the Pinecone index you want to query.

4. Namespace (string, optional): An optional namespace within the Pinecone index to scope your query.

Output

• The node outputs a field called Results, which contains the similar vectors found in the database, along with their metadata.

Example Usage

• If you want to find the top 5 most similar vectors to the phrase "StackAI product launch" in your "company-updates" index, you would set:

  • Query: "StackAI product launch"

  • Number of Results: 5

  • Index Name: "company-updates"

  • Namespace: (leave blank or specify if needed)

The Pinecone node will then return the most relevant vectors, which you can use for recommendations, search, or further processing in your workflow.

The LinkedIn Node in StackAI enables seamless integration with LinkedIn, the leading professional networking platform. This node allows you to automate LinkedIn-related tasks, such as searching for profiles, extracting professional data, and more, directly within your workflow/

Example of Usage

Suppose you want to search for professionals in a specific industry and extract their public profile data. You would use the LinkedIn node, select the "Search" action, provide the search keywords as input, and configure any optional filters. The output will be a list of matching LinkedIn profiles with relevant details.

Available Actions

1. LinkedIn Search

Description: Search for professionals, companies, or jobs on LinkedIn based on keywords and filters.

Inputs:

• Keywords (Required): The search terms to find relevant profiles or companies. Example: "Data Scientist San Francisco"

• Filters (Optional): Additional filters such as location, industry, or company size. Example: {"location": "San Francisco", "industry": "Technology"}

Configurations:

• Query Filter: which fields of the JSON to include in the output

• Top K: how many results to return

• LinkedInSearchType: search generally, or for jobs, companies, or content

• CountryCode: the country to search in

Outputs:

• Results (Always Provided): A list of LinkedIn profiles, companies, or jobs matching the search criteria. Example:

  Copy

  [
    {
      "name": "Jane Doe",
      "title": "Senior Data Scientist",
      "company": "TechCorp",
      "location": "San Francisco"
    },
    ...
  ]

To use the NetSuite Node in StackAI, use the Custom SuiteQL action. This action allows you to query Netsuite and retrieve any data stored there with a SQL query.

Creating a Connection to NetSuite

StackAI recommends creating connections using a dedicated user account with permissions scoped for the task in question.

To create a connection, select + NetSuite (OAuth). Then, log in with the user account.

Here, you will be prompted to enter your Account ID, Client ID, and Client Secret.

Permissions

Give your service account user role permissions, and access to the necessary tables that you will be retrieving or writing data to. For access through StackAI, you may need to additionally give the service account permissions for "Analytics and REST" access to the table in question. For access to Messages for example, delegate permissions for Messages and also for Messages Analytics and REST

Tips

Always list the fields explicitly in your query:

SELECT id, subject, author, recipient, activitydate
FROM message
WHERE activitydate >= '2025-01-01'

You may not be able to use SELECT * when querying Netsuite. Your user may not have permissions to all fields, causing an error. NetSuite is also not a traditional relational database; some fields are dynamically defined.

The Regex Node in your workflow uses the Regex Extract action. This tool allows you to extract specific patterns or information from a block of text using regular expressions (regex).

Available Actions

Regex Extract

• Purpose: Extracts content from text using a regular expression pattern you provide.

• Provider: Regex

Inputs Required

1. Content (string, required)

   • The text you want to extract information from.

   • Example: "Order number: 12345, Date: 2025-07-10"

2. Expression (string, required)

   • The regular expression pattern to search for in the content.

   • Example: "Order number: (\d+)"

Output

• Result (string)

  • The extracted value(s) from the content that match your regex pattern.

How to Use the Regex Node

1. Connect the node: Pass the text you want to analyze (from an LLM, input, or another node) into the Regex node.

2. Configure the action:

   • Set the "Content" field to the text you want to search.

   • Set the "Expression" field to your desired regex pattern.

3. Use the output: The result will be available as {action-X.result} (where X is the node number) for downstream nodes.

Example Usage

Suppose you want to extract an order number from a message:

• Content: "Order number: 12345, Date: 2025-07-10"

• Expression: "Order number: (\d+)"

• Result: "12345"

You can reference this result in other nodes using {action-3.result} if your Regex node is action-3.

Prompt Engineering and Context Management

• Prompt Customization: Each LLM node can have its own prompt and system message. Tailor these to the specific sub-task each LLM is handling.

• Context Passing: Use node references (e.g., {llm-0}) in prompts to pass context or results between LLMs.

Prompting Best Practices

Prompting with Tools

When using tools in an LLM Node, include them in your prompt with the @ sign.

XML Tags

For long prompts, or prompts that reference multiple inputs, group them with XML tags. Grouping signals to the LLM where certain associated blocks of information begin and end.

The File Node allows users to upload a file to the flow and use it as an input to the LLM. The File Node is not a Knowledge Base like the Documents Node; RAG will not be performed over the files. Instead, the file will always be given directly to the LLM as context.

Expose as Input: This toggle displays the file node as an available input on the user-facing interface, allowing the user to upload their own file. Toggle this OFF to keep the files static. The workflow will then always use the files you uploaded, and the user won't be able to change this.

Files Node Settings

Click on the node to see the available settings.

Chunking Settings

• Chunking Algorithm: Defines how the data is split (e.g., Sentence-based).

• Chunk Overlap: The number of overlapping tokens between chunks.

• Chunk Length: Max length of each chunk sent to the LLM.

Additional Features

• Advanced Data Extraction: Enable more precise field-level parsing (toggle option).

• Text in Images (OCR): Extract and include text from images (toggle option)

How to Use the File Node

1. Add a File node to your flow.

2. Connect the File node to an LLM node.

3. Mention the File node in the LLM node by pressing "/" and selecting the File node.

   1. Files (documents) is a reference to the contents (text) of the file, split into chunks

   2. Files (raw_text) is a reference to the contents of the file, completely unchunked

   3. Files (file_urls) is a reference to the actual file--useful if you need to instruct the LLM to attach the file to an email or send the file using SFTP.

4. Add an Output node to your flow.

5. Connect the Output node to the LLM node.

How to Expose the File Node to your Users

1. Go to the Export tab.

2. Enable the file node in the Inputs section.

3. Press Save Interface to save your changes.

4. Your users should now see an upload button in the interface.

Data Node

When you create a Data node, you will see a button to upload data to the Vector Store API. You can find the API documentation here.

Google Drive Node

Authenticate through Google to give your project access to your Google Drive. Your end users will be able to ask an LLM questions based on the files you've uploaded.

Sharepoint Node

The Sharepoint Node allows you to index two types of media: documents stored in Sharepoint and Sharepoint News, where everything on the page is indexed.

To authenticate to your Sharepoint organization account, you must follow these steps:

• Go to App Registrations in Azure: visit your Azure Portal and go to "App Registrations" here.

• Create App: Click on "New Registration". Add a name to your app and select "Accounts in this organizational directory only (Default Directory only - Single tenant)".

• Get Client ID and Tenant ID: get your client and tenant id from the "Essentials" section. You will find them under "Application (client) ID" and "Directory (tenant) ID ".

• Create a client secret: Navigate to "Certificates & Secrets" then click on "New client secret". Give an expiration date to your secret. Finally, you will find the client secret in the "Value" field of the secret.

• Add Scopes: Naviate to "App Permissions" and then click on "Add a permission". Click on "Microsoft Graph" and select "Application Permissions". Then select the following scopes: Sites.ReadAll, Files.ReadAll, BrowserSiteLists.Read.All. Then click on "Add Permissions". Finally click on "Grant Admin Consent for Default Directory".

Now you can proceed to add your node in Stack AI add add the value of your client_id, client_secret, tenant_id, site_id, and folder path.

Table Node

Use a Table Node to create a Knowledge Base from a .csv file. StackAI creates a SQL database with your .csv file and performs semantic search, all under the hood. A generative model decides which search result--SQL or semantic search--is more informative, giving you powerful search over tables.

Websites Node

The Website Node allows you to create a Knowledge Base from a website URL. The URLs that you upload are then indexed and stored in a vector data base - don't worry, we do this for you in the background! This process is done once, so that you can later query this knowledge base and only retrieve the pieces of information that are more related to your query. It's the most efficient way to manage a long list of URLs, without having to index them everytime you run the workflow (i.e., embeddings are generated only once, when you upload the URLs).

Jira Node

The Jira Node allows you to create a knowledge base from Jira projects. To use this node, first establish a connection to Jira, see how to do so here. You will be able to select which projects to include in your knowledge base and perform RAG over those projects.

In the Prompting section of the LLM Node, you will see two sections: Instructions, and Prompt.

System Prompt

The system prompt sets the overall behavior, tone, and role of the AI assistant for the entire conversation. It acts as a set of instructions or context that the model should always keep in mind when generating responses. This message is passed into the model's context each time you interact with it, so the model with always "remember" what you say here. It's important to keep this part as short and informative as you can. Put only the most important information into this section. It’s best used for setting rules, style, or persona (e.g., “You are a helpful tutor. Always explain things simply.”).

User Prompt

The user prompt is the main message or question that the LLM will answer. It can include direct user input, references to other nodes, or additional context. This is the main content the LLM will respond to, after considering the system prompt.

Include placeholders in your user prompt if you'd like to import output from other nodes (e.g., user input). You can do this by typing backslash and then selecting the node whose output you'd like to include.

If you need help with your prompt, try our Magic Wand tool on the bottom right of the prompt box.

To learn more about prompting best practices, go here.

This guide will walk you through how to set a default connection for your preferred LLM provider. You'll also learn how to disable the use of StackAI API keys across providers, deactivate specific LLM providers, and manage other advanced configuration options.

Let’s start!

1. Creating a Default Connection

Navigate to Settings on the bottom left of your screen, underneath your avatar. Then, select Feature Access from the menu.

Under the LLMs section, search for Local LLMs—you can follow the same steps for any other provider as well. If needed, this is also where you can disable specific LLM providers to prevent your users from accessing them.

Once you're in the tab for a specific LLM provider, you'll see a toggle to enable or disable the provider, as well as a "New Connection" button under Default Connection to define it as your primary connection.

Once you click the button, you can create a connection that will serve as the default for all LLMs from that provider within your workspace. This is especially useful because your users won’t need to manually enter an API key to use those models.ally.

2. Using a Local LLM

Once the connection is set up, you can create a new project, choose your LLM provider, select the specific model you want to use, and start interacting with it immediately.

You won’t need to manually add the connection—your default connection will appear automatically at the bottom. If you prefer to use a different connection, you can create it directly from that section and select it for your project.

3. Connections Manager

All your connections are stored in the Connections Manager tab. You can also create new connections from there, and easily select any of them when adding an LLM node to your project.

You can choose to make your connections either public or private, and you’re free to change the default connection at any time. Simply go to the Access Control tab in your Settings to update this preference.

3. Disconnecting all StackAI’s API keys usage

If you'd like to prevent any unintended usage of LLMs without your API keys, you can disable all StackAI API Keys. This ensures that only LLMs configured to send data to your own servers are allowed. To do this, navigate to Settings > Feature Access > Other > General LLM Configuration.

Local LLMs

Stack AI allows organizations to connect and use their own local LLMs (such as models hosted on private infrastructure or on-premise servers) instead of relying solely on cloud-based models like OpenAI or Bedrock.

Governance Benefits:

• Data Privacy: Your data never leaves your infrastructure, ensuring compliance with strict privacy or regulatory requirements.

• Custom Control: You can select, update, or fine-tune models as needed, and restrict which users or workflows can access them.

• Auditability: All usage of the local LLM can be logged and monitored within your organization’s security perimeter.

How it works in Stack:

• Admins can add a local LLM as a provider in the Stack AI admin console. See

• Once added, the local LLM appears as an option in the workflow builder, just like any other provider.

• You can set permissions to control which users or teams can access the local LLM.

Turning Off Stack API Keys

By default, Stack AI provides hosted API keys for popular providers (like OpenAI, Anthropic, etc.) so users can get started quickly. However, for governance and security, organizations may want to require the use of their own API keys or connections.

Governance Benefits:

• Credential Control: Prevents users from accidentally or intentionally using Stack’s shared keys, ensuring all API usage is billed to and controlled by your organization.

• Security: Reduces risk of data leakage or misuse of shared credentials.

• Compliance: Ensures all API access is auditable and tied to your organization’s own accounts.

How it works in Stack:

• Admins can disable Stack-provided API keys for any provider in the admin console.

• Once disabled, users must add their own connection (API key) to use that provider in workflows.

• This setting can be enforced globally or per-provider.

Deactivating Certain Providers

Stack AI supports a wide range of providers (OpenAI, Bedrock, Google, Slack, etc.). For governance, you may want to restrict which providers are available to your users.

Governance Benefits:

• Risk Mitigation: Prevents use of unapproved or high-risk providers.

• Simplified Compliance: Ensures only vetted and compliant services are available.

• User Experience: Reduces clutter and confusion by hiding unused or irrelevant providers.

How it works in Stack:

• Admins can deactivate (hide or block) any provider from the admin console.

• Deactivated providers will not appear in the workflow builder or connection menus for end users.

• This can be managed at the organization or workspace level.

Summary Table

The Algolia Node in Stack AI allows you to search your Algolia index using natural language or semantic queries. This integration is ideal for retrieving relevant data, documents, or records from your Algolia-powered search infrastructure directly within your AI workflows.

How to use it?

Add the Algolia node to your Stack AI workflow to execute search queries against your Algolia index. Connect an input node or LLM node to provide the search query, and use the results in downstream nodes for further processing or display.

Example of Usage

Suppose you want to search for documentation related to "API authentication" in your Algolia index. You would connect an input node (where the user types their query) to the Algolia node, and the Algolia node will return the most relevant results.

Available Actions

1. Database Query (Algolia Search)

Description: Executes a search query against your Algolia index and returns matching results.

Inputs

Showing 1-1 of 1 items

Example Input:

Configurations

There are no additional configuration parameters required for the Algolia Database Query action. All you need is the search query input.

Outputs

Showing 1-1 of 1 items

Example Output:

Summary Table

Establishing a Connection

1. Connection Name

A user-friendly name for your connection. This helps you identify it among other connections in Stack AI.

2. Instance URL

Go to

The URL in your browser’s address bar is your instance URL. It usually looks like: https://<instance>.service-now.com

3. Username

In that same card, copy the username that is underneath the URL.

4. Password

This is the password for the ServiceNow user account above. This is used together with the username for authentication.

Copy the password under "Current password."

5. Client ID

In the video below, you will find how to generate a Client ID and Client Secret by creating an OAuth API endpoint. To follow the steps in the video guide, go to the homepage of your ServiceNow instance: https://<instance>.service-now.com

6. Client Secret

To get the client secret, click on the resource you've created and then click on the copy button to the right, next to Client Secret.

When using multiple LLMs in one project, there are important points to consider in order to ensure they work well together.

Clear Input/Output Flow

• Explicit Connections: Each LLM node should have clearly defined input and output connections. Use Input nodes (in-0, in-1, etc.) to gather user data, and connect them to the relevant LLM nodes.

• Output Handling: Route the output of each LLM node to Output nodes or downstream processing nodes (like Template or Python nodes) for further formatting or logic.

Sequential vs. Parallel LLMs

• Sequential Orchestration: If the output of one LLM is needed as input for another, connect them in sequence (e.g., llm-0 → llm-1). This is useful for multi-step reasoning or refinement. Having initial LLMs give structured outputs to downstream LLMs can be helpful.

• Parallel Orchestration: If you want to compare or aggregate results from multiple LLMs, connect the same input to several LLM nodes in parallel, then merge their outputs downstream using the Combine Node or a third LLM that will summarize and logically merge the two outputs

Memory and State

• Sliding Window Memory: Use the memory feature in LLM nodes to maintain context across turns or steps, especially in multi-turn workflows.

• Stateful Processing: If you need to track or update state, consider using Python nodes between LLMs to manipulate or store intermediate results.

Error Handling and Fallbacks

• On Failure Branches: Configure on_failure_branch and retry settings for each LLM node to handle errors gracefully.

• Fallback LLMs: Use the fallback options to specify alternative models/providers if the primary LLM fails.

Data Formatting and Validation

• Template Nodes: Use Template nodes to format or merge outputs from multiple LLMs before presenting to the user.

• Output Validation: If LLMs are expected to return structured data (e.g., JSON), use the json_schema parameter to enforce output format and validate results.

Chaining with Other Nodes

• Integration with Actions: LLM outputs can be passed to Action nodes (e.g., sending emails, updating databases) for real-world effects.

• Custom Logic: Insert Python nodes between LLMs for custom logic, filtering, or aggregation.

Citations and Traceability

• Citations: Enable citations in LLM nodes if you want to track sources or provide references in the output.

• Auditability: Use Output nodes and logs to trace the flow of data and decisions across multiple LLMs.

Performance and Latency

• Parallelization: Where possible, run LLMs in parallel to reduce overall latency.

• Token and Cost Management: Set appropriate max_tokens and temperature settings to control cost and response quality.

Summary Table:

Chunking: Optimizing Data Retrieval in Stack AI Workflows

Chunking is a key technique in AI-powered document processing. In StackAI, using the right chunking strategy can greatly enhance how effectively machine learning models understand and extract data from documents.

What is Chunking in StackAI?

Chunking = Breaking large documents into smaller, manageable parts.

• Used in StackAI’s "Files" and "Documents" nodes.

• Ensures input fits within AI model token limits.

• Can be configured via the gear icon in relevant nodes.

Chunking Methods

1. Naïve Chunking (Fixed-Length)

Splits text by character, word, or token count.

• Pros:

  • Fast and simple to implement

  • Predictable processing time

• Cons:

  • May break sentences or ideas

  • Can reduce AI comprehension

2. Sentence-Based Chunking

Splits text along natural sentence boundaries.

• Pros:

  • Preserves meaning and structure

  • Enhances AI understanding

• Cons:

  • More computationally intensive

  • Chunk sizes can vary

Optimizing Chunk Configuration

Chunk Size

• Choose based on your model's capabilities.

• Tradeoff:

  • Larger chunks = better context but risk hitting token limits.

  • Smaller chunks = faster, but may lose coherence.

• Recommended: 200–1,000 tokens

Chunk Overlap

• Adds continuity between chunks.

• Suggested: 15–30% overlap

Best Practices for Stack AI Users

• Use sentence-based chunking for documents with rich content.

• Tune chunk size to match your AI model's limits.

• Experiment with overlap percentages to preserve context.

• Iteratively test to ensure optimal results.

Technical Tips

• Configure chunking inside "Files" and "Documents" nodes.

• Continuously monitor model performance as you adjust settings.

• Align your chunking strategy with your specific ML model needs.

Why It Matters

Mastering chunking helps:

• Improve document comprehension for AI

• Boost data extraction accuracy

• Deliver better performance across document-based workflows in StackAI

Add Memory

Add memory to your LLMs in Stack AI. Improve user interaction by enabling models to remember previous conversations and provide more context-aware responses.

LLMs do not hold an internal state, and many applications require tracking previous interactions with the LLM as part of the interface (e.g. chatbots). To this end, you can add memory to an LLM node under the Stack AI tool by clicking on the gear icon of the LLM node.

Some quick facts:

• All the LLM memory is encrypted end-to-end in the Stack AI database.

• This data can be self-hosted under the Stack AI enterprise plan.

• The LLM memory is user-dependent and an instance of the LLM memory.

• Once the deployed as an API, you can specify the user_id for the LLM memory for each user (see Deployer Guide ).

• By default, the “Sliding Window Input” memory is selected when a new LLM node is added to the flow.

We offer three types of memory modalities:

• Sliding Window

  • Stores all LLM prompts and completions.

  • This strategy may consume many tokens as the LLM prompts can often occupy thousands of tokens.

  • Loads a window of the previous prompts and completions as part of the LLM conversation memory, up to the number of messages in the window.

  • In non-chat models (e.g. Davinci), the memory is added as part of the prompt as a list of messages at the end of the prompt.

• Sliding Window with Input

  • Stores one LLM input parameter (e.g. in-0) and all LLM completions, without storing the entire prompt from each turn.

  • This strategy is more token efficient and aligned with many applications (e.g. when only the user message from input is relevant)

  • Loads a window of the previous inputs and completions as part of the LLM conversation memory, up-to the number of messages in the window. In non-chat models (e.g. davinci-003-text), the memory is added as part of the prompt as a list of messages at the end.

• VectorDB

  • Stores all of the inputs and outputs to the LLM in a Vector Database and retrieves the most relevant messages to use as LLM memory.

  • This is especially useful if you expect some of the information to be needed at a later time but not in a sequential manner.

  • Allows the LLM to access older, contextually relevant interactions without the constraint of a fixed window size.

Sliding Window

The sliding window allows you to set the number of turns you would like to be included in your context.

Input Id

If you chose to have 'Sliding Window with Input' saved in memory, then you can also select the id of the input that you would like to be held in context. All other inputs will not be stored in context.

Citations

Turn on citations to allow the AI to provide citations (references) for the information it generates, especially when it uses external sources or uploaded documents.

Response Format

Text is the default response format. You can also choose to have the AI return a response formatted as a JSON object

JSON Object with Schema

To have an LLM output a JSON object according to a provided schema, you must provide the schema in the following format. JSON schemas not formatted according to this specification may throw an error.

• "strict": true if you want to enforce exactly this output schema

• "description": a description of your schema

• "schema": the actual schema of your ouput

  • "type": set to "object" if you would like to return a JSON object

  • "properties": the outputs you would like to return, include each outputs type, and an informative description for the LLM

{
    "strict": true,
    "name": "weather-schema",
    "description": "Schema for a weather API request",
    "schema": {
        "type": "object",
        "properties": {
            "location": {
                "type": "string",
                "description": "The location to get the weather for"
            },
            "unit": {
                "type": "string",
                "description": "The unit to return the temperature in",
                "enum": ["F", "C"]
            }
        },
        "additionalProperties": false,
        "required": ["location", "unit"]
    }
}

What is BigQuery?

BigQuery is a fully managed, serverless data warehouse by Google Cloud that enables super-fast SQL queries using the processing power of Google's infrastructure. In StackAI workflows, the BigQuery node allows you to connect, query, and interact with your Google BigQuery datasets directly from your automated flows.

How to Use the BigQuery Node

The BigQuery node in StackAI is designed to execute SQL queries on your Google BigQuery database. It can be used to retrieve, analyze, and process large datasets as part of your workflow automation. You can connect this node to other nodes to automate data-driven tasks, reporting, or trigger downstream actions based on query results.

Example of Usage

Suppose you want to retrieve sales data for the last month from your BigQuery database and use it in a report. You would configure the BigQuery node with your SQL query, connect your Google Cloud credentials, and pass the results to a reporting or output node.

Available Actions for BigQuery

1. Database Query (BigQuery)

Description: Run a SQL query against your Google BigQuery database and retrieve the results for use in your workflow.

Inputs

Showing 1-2 of 2 items

Configurations

Showing 1-4 of 4 items

Outputs

Showing 1-3 of 3 items

Example Configuration

{
  "action_id": "database_query_bigquery",
  "action_configurations": {
    "connection_id": "bq-connection-12345",
    "project_id": "my-gcp-project",
    "dataset_id": "sales_data",
    "location": "US"
  },
  "action_input_parameters": {
    "query": "SELECT * FROM sales WHERE date > '2025-06-01'",
    "parameters": {}
  }
}

What is Box?

Box is a leading cloud content management and file sharing service for businesses. The Box integration in StackAI allows you to automate, manage, and interact with your Box files, folders, metadata, and user permissions directly within your workflows. This enables seamless collaboration, secure file storage, and efficient document handling without leaving the StackAI platform.

How to use it?

To use the Box integration in StackAI, add the Box node to your workflow. You can then select from a wide range of actions to interact with your Box account, such as uploading files, managing folders, sharing documents, and handling metadata. Each action can be configured with specific inputs and settings to match your automation needs.

Example of Usage

Scenario: Automatically upload a file to a specific Box folder when a new document is generated in your workflow.

1. Add the Box node to your StackAI workflow.

2. Select the "Upload File" action.

3. Configure the required inputs:

   • file (Required): The file to upload (e.g., from a previous node).

   • parent_folder_id (Required): The ID of the Box folder where the file will be uploaded.

4. Optionally, set configurations such as connection ID for authentication.

5. Use the output (uploaded file details) in downstream nodes for further processing or notifications.

Most Commonly Used Actions in Box

Below are the most frequently used Box actions in StackAI, along with their input, configuration, and output details:

1. Upload File

Description: Uploads a file to a specified folder in your Box account.

Inputs:

• file (Required): The file object or path to upload.

• parent_folder_id (Required): The ID of the destination folder in Box.

• name (Optional): The name for the uploaded file.

Configurations:

• connection_id (Required): Your Box connection for authentication.

Outputs:

• id: The unique ID of the uploaded file.

• name: The name of the uploaded file.

• created_at: Timestamp of file creation.

• modified_at: Timestamp of last modification.

• size: File size in bytes.

Example:

{
  "file": "{doc-0}",
  "parent_folder_id": "123456789",
  "name": "report.pdf"
}

2. Download File

Description: Downloads a file from Box using its file ID.

Inputs:

• file_id (Required): The ID of the file to download.

Configurations:

• connection_id (Required): Your Box connection for authentication.

Outputs:

• file_content: The binary content of the downloaded file.

Example:

{
  "file_id": "987654321"
}

3. Create Folder

Description: Creates a new folder in a specified parent folder.

Inputs:

• name (Required): The name of the new folder.

• parent_folder_id (Required): The ID of the parent folder.

Configurations:

• connection_id (Required): Your Box connection for authentication.

Outputs:

• id: The unique ID of the new folder.

• name: The name of the new folder.

Example:

{
  "name": "Project Files",
  "parent_folder_id": "123456789"
}

4. List Folder Items

Description: Lists all items (files and folders) within a specified folder.

Inputs:

• folder_id (Required): The ID of the folder to list items from.

Configurations:

• connection_id (Required): Your Box connection for authentication.

Outputs:

• entries: Array of items (files/folders) in the folder.

• total_count: Total number of items.

Example:

{
  "folder_id": "123456789"
}

5. Share File or Folder (Get Shared Link)

Description: Generates a shared link for a file or folder.

Inputs:

• file_id or folder_id (Required): The ID of the file or folder to share.

• access (Optional): Access level (e.g., "open", "company", "collaborators").

Configurations:

• connection_id (Required): Your Box connection for authentication.

Outputs:

• shared_link: The generated URL for sharing.

Example:

{
  "file_id": "987654321",
  "access": "open"
}

What is the Coda Node?

The Coda node in StackAI enables seamless integration with Coda, allowing you to automate document management, data updates, and workflow actions directly within your StackAI flows. With this node, you can create, update, and manage Coda docs, pages, tables, and rows, streamlining your business processes and boosting productivity.

How to Use the Coda Node?

To use the Coda node, simply add it to your StackAI workflow and select the desired action. Connect your Coda account using a valid connection ID, then configure the required inputs and settings for your chosen action. The node will execute the action and return the results, which can be used in downstream nodes for further automation.

Example of Usage

Suppose you want to add a new row to a Coda table whenever a new lead is captured. You would use the "Upsert Rows" action, provide the required Doc ID, Table ID, and row data, and connect the output to your reporting or notification nodes.

Most Commonly Used Actions in the Coda Node

Below are the most popular and useful Coda actions available in StackAI, along with detailed input, configuration, and output explanations:

1. List Docs

Description: Retrieve a list of all Coda docs accessible to your account.

• Inputs:

  • None required.

• Configurations:

  • connection_id (Required): Your Coda connection ID.

• Outputs:

  • docs: Array of document objects, each containing doc ID, name, and other metadata.

Example:

{
  "action_configurations": { "connection_id": "<your-coda-connection-id>" },
  "action_input_parameters": {}
}

2. Create Doc

Description: Create a new Coda document.

• Inputs:

  • title (Required): The name of the new document.

• Configurations:

  • connection_id (Required): Your Coda connection ID.

• Outputs:

  • doc_id: The unique ID of the created document.

  • name: The name of the document.

Example:

{
  "action_configurations": { "connection_id": "<your-coda-connection-id>" },
  "action_input_parameters": { "title": "Project Plan" }
}

3. List Tables

Description: List all tables in a specified Coda doc.

• Inputs:

  • doc_id (Required): The ID of the Coda document.

• Configurations:

  • connection_id (Required): Your Coda connection ID.

• Outputs:

  • tables: Array of table objects with table IDs and names.

Example:

{
  "action_configurations": { "connection_id": "<your-coda-connection-id>" },
  "action_input_parameters": { "doc_id": "abc123" }
}

4. Upsert Rows

Description: Add or update rows in a Coda table.

• Inputs:

  • doc_id (Required): The ID of the Coda document.

  • table_id (Required): The ID of the table within the document.

  • rows (Required): Array of row objects to insert or update.

• Configurations:

  • connection_id (Required): Your Coda connection ID.

• Outputs:

  • row_ids: Array of IDs for the upserted rows.

Example:

{
  "action_configurations": { "connection_id": "<your-coda-connection-id>" },
  "action_input_parameters": {
    "doc_id": "abc123",
    "table_id": "table456",
    "rows": [{ "Name": "John Doe", "Email": "[email protected]" }]
  }
}

5. Get Row

Description: Retrieve a specific row from a Coda table.

• Inputs:

  • doc_id (Required): The ID of the Coda document.

  • table_id (Required): The ID of the table.

  • row_id (Required): The ID of the row to retrieve.

• Configurations:

  • connection_id (Required): Your Coda connection ID.

• Outputs:

  • row: Object containing the row data.

Example:

{
  "action_configurations": { "connection_id": "<your-coda-connection-id>" },
  "action_input_parameters": {
    "doc_id": "abc123",
    "table_id": "table456",
    "row_id": "row789"
  }
}

What is Crunchbase?

The Crunchbase node in StackAI allows you to access and search company and investment data directly from Crunchbase. This integration is ideal for workflows that require up-to-date business intelligence, company profiles, or investment research.

How to use it?

To use the Crunchbase node, simply add it to your StackAI workflow and configure the search parameters. You can specify your search query, the number of results you want, and the country to focus your search. The node will return structured results with company or investment information.

Example of Usage

Suppose you want to find information about "OpenAI" in the United States and retrieve the top 5 results:

• Query: "OpenAI" (required)

• Top K: 5 (optional, default is 10)

• Country: "US" (optional, default is "US")

The node will return a list of results, each containing a title and a text summary.

Available Actions

1. Crunchbase Search

Description: Searches Crunchbase for companies, investments, or related data based on your query.

Inputs

Configurations

• Country Options: AR, AU, AT, BE, BR, CA, CL, CN, CO, CZ, DK, FI, FR, DE, HK, IN, ID, IT, JP, KR, MY, MX, NL, NZ, NO, PH, PL, PT, RU, SA, SG, ZA, ES, SE, CH, TW, TH, TR, GB, US

Outputs

Each result object contains:

• Title (required): The title of the Crunchbase result (e.g., "OpenAI, Inc.")

• Text (required): The text content or summary of the result (e.g., "OpenAI is an AI research and deployment company...")

Example Output

{
  "query": "OpenAI",
  "search_results": [
    {
      "title": "OpenAI, Inc.",
      "text": "OpenAI is an AI research and deployment company based in San Francisco, CA..."
    },
    {
      "title": "OpenAI LP",
      "text": "OpenAI LP operates as a limited partnership for AI research and development..."
    }
    // ...more results
  ]
}

How to Use the Excel Node

To use the Excel node, simply add it to your StackAI workflow and configure it to perform actions such as writing data to a spreadsheet. You can connect it to other nodes (like LLMs, input nodes, or data sources) to automate the flow of information into your Excel files. The node supports secure authentication via connection IDs, ensuring your data remains protected.

Example of Usage

Suppose you want to automatically log survey responses from a form into an Excel spreadsheet stored in SharePoint. You can connect the input node (collecting responses) to the Excel node, which then writes each new entry into the designated spreadsheet, eliminating manual data entry.

Available Actions for the Excel Node

Below are the most commonly used actions for the Excel node in StackAI:

1. Write to Sheet

Description: Automatically writes data to a specified Excel sheet in SharePoint.

Inputs

Showing 1-4 of 4 items

Example Input:

{
  "spreadsheet_id": "abc123",
  "sheet_name": "Responses",
  "data": [
    {"Name": "John Doe", "Email": "[email protected]", "Score": 95}
  ],
  "range": "A2:C2"
}

Configurations

Showing 1-1 of 1 items

Example Configuration:

{
  "connection_id": "your-connection-id-here"
}

Outputs

Showing 1-3 of 3 items

Example Output:

{
  "success": true,
  "updated_range": "A2:C2"
}

Best Practices

• Always ensure your connection ID is valid and has the necessary permissions to access the target Excel file.

• Validate your data structure before writing to avoid errors.

• Use dynamic node references (e.g., {in-0}) to automate data flow from other nodes.

Summary

The Excel node in StackAI is a powerful tool for automating spreadsheet operations in SharePoint. By leveraging its write capabilities, you can streamline data management, reduce manual work, and enhance collaboration across your team.

GDocs in StackAI allows you to automate the creation of Google Docs directly from your workflow. The GDocs Node integration streamlines document generation, making it easy to create, organize, and access Google Docs using dynamic data and AI-powered content.

How to use it?

To use the GDocs node, connect it in your StackAI workflow where you want to generate a new Google Doc. You can specify the document’s name, content (in Markdown), and optionally the folder where it should be stored in your Google Drive. The node will output the document’s unique ID and a direct link to open it.

Example of Usage

Suppose you want to generate a project report automatically after processing some data. You can use the GDocs node to create a new document titled "Project Report" with the body content generated by an LLM node, and save it in a specific Google Drive folder.

Available Actions

1. Create Google Doc

Description: Creates a new Google Doc with specified content and file name, optionally placing it in a chosen Google Drive folder.

Inputs:

• File Name (Required):

  • Type: String

  • Description: Name of the Word document to create.

  • Example: "Project Report"

• Content (Required):

  • Type: String (Markdown)

  • Description: Document body text in Markdown format.

  • Example: "## Executive Summary\nThis report covers..."

• Folder ID (Optional):

  • Type: String

  • Description: Google Drive folder ID where the file will be created. Leave blank to create in My Drive.

  • Example: "1A2B3C4D5E6F"

Configurations: No additional configurations are required for this action.

Outputs:

• File ID (Required):

  • Type: String

  • Description: Unique identifier of the created Google Doc.

  • Example: "1x2y3z4w5v6u"

• File URL (Required):

  • Type: String

  • Description: URL to open the document in Google Drive.

  • Example: "https://docs.google.com/document/d/1x2y3z4w5v6u/edit"

Example Workflow Step

• Set up an LLM node to generate a summary.

• Connect the LLM output to the GDocs node’s Content input.

• Set File Name to "Weekly Summary".

• (Optional) Provide a Folder ID to organize the document.

• The GDocs node will output a File ID and a File URL for immediate access.

Summary Table

Note: To use this node, ensure your StackAI workspace is connected to Google Drive with the necessary permissions. Use the Folder ID to organize documents as needed, or leave it blank to save in your main Drive.

The Gmail Node in StackAI enables you to automate sending and managing emails directly through your Gmail account. This integration streamlines communication tasks, allowing you to trigger email actions within your automated workflows.

How to use it?

To use the Gmail node, connect your Gmail account using a valid connection ID. Choose the desired action (such as sending an email), provide the required input fields, and configure any optional settings. The node will execute the action and return the relevant output, which can be used in downstream workflow steps.

Example of Usage

Suppose you want to automatically send a notification email when a new lead is added to your CRM. You can set up a workflow where the Gmail node is triggered with the lead’s details, and an email is sent to your sales team.

Available Actions

Below are the most commonly used actions for the Gmail node in StackAI:

1. Send Email

Description: Send an email from your connected Gmail account to one or more recipients.

Inputs:

• to (Required): The recipient’s email address or a list of addresses. Example: "to": "[email protected]" or "to": ["[email protected]", "[email protected]"]

• subject (Required): The subject line of the email. Example: "subject": "Welcome to Our Service"

• body (Required): The main content of the email. Example: "body": "Thank you for signing up!"

• cc (Optional): Email addresses to be copied on the email. Example: "cc": "[email protected]"

• bcc (Optional): Email addresses to be blind-copied on the email. Example: "bcc": "[email protected]"

• attachments (Optional): List of file paths or file objects to attach. Example: "attachments": ["/path/to/file.pdf"]

Configurations:

• connection_id (Required): The ID of your Gmail connection. Example: "connection_id": "5a56b86a-c7d3-4e6a-af3f-0969d00ff9f8"

Outputs:

• message_id (Always returned): The unique ID of the sent email. Example: "message_id": "17c8b2e5e8b2c1a2"

• status (Always returned): The status of the email send operation. Example: "status": "sent"

2. Search Emails

Description: Search for emails in your Gmail account using specific criteria.

Inputs:

• query (Required): The search query string (Gmail search syntax). Example: "query": "from:[email protected] is:unread"

• max_results (Optional): Maximum number of emails to return. Example: "max_results": 10

Configurations:

• connection_id (Required): The ID of your Gmail connection.

Outputs:

• emails (Always returned): A list of email objects matching the search criteria. Example:

  Copy

  "emails": [
    {
      "subject": "Meeting Reminder",
      "from": "[email protected]",
      "date": "2025-07-07T10:00:00Z",
      "snippet": "Don't forget our meeting at 2pm."
    }
  ]

3. (Optional) Additional Actions

Other actions may be available, such as managing labels or retrieving email details. For most workflow automations, "Send Email" and "Search Emails" are the primary actions used.

Best Practices

• Always use a valid Gmail connection ID from your available connections.

• Ensure all required fields are provided for each action.

• Use dynamic references (e.g., from previous nodes) to personalize email content or search queries.

• Attachments should be properly formatted and accessible by the workflow.

Summary Table

Use the Gmail node in StackAI to automate your email workflows, streamline communication, and enhance productivity with seamless Gmail integration.

What is GSheets?

GSheets is a StackAI integration node that allows you to write data directly to Google Sheets. This node is ideal for automating data entry, updating records, or logging information in your spreadsheets as part of your workflow.

How to use it?

To use the GSheets node, you need to configure it with the required spreadsheet and sheet details, and provide the data you want to write. The node will then append or update the specified Google Sheet with your data and return the status of the operation.

Example of Usage

Suppose you want to log new user signups into a Google Sheet. You can connect the GSheets node in your StackAI workflow, configure it with your target spreadsheet and sheet, and pass the signup data as input.

Available Actions

1. Write to Google Sheet

Description: Appends or updates data in a specified Google Sheet.

Inputs

• Spreadsheet (spreadsheet_id)

  • Required: Yes

  • Type: Select

  • Description: Select the Google Sheet to write to.

• Sheet (sheet_name)

  • Required: Yes

  • Type: String

  • Description: Specify the sheet/tab within the spreadsheet.

• Data (data)

  • Required: Yes

  • Type: Textarea

  • Description: The data to write. Can be a JSON object (preferred for structured data) or plain text.

Example Input:

{
  "spreadsheet_id": "1A2B3C4D5E6F7G8H9I0J",
  "sheet_name": "Signups",
  "data": {
    "Name": "Jane Doe",
    "Email": "[email protected]",
    "Signup Date": "2025-07-07"
  }
}

Configurations

• No additional configurations are required beyond the inputs above.

Outputs

• Status (status)

  • Required: Yes

  • Type: String

  • Description: Indicates if the operation was successful (e.g., "success" or "failure").

• Updated Range (updated_range)

  • Required: Yes

  • Type: String

  • Description: The cell range in the sheet that was updated (e.g., "Signups!A2:C2").

• Message (message)

  • Required: Yes

  • Type: String

  • Description: A message describing the outcome of the operation.

Example Output:

{
  "status": "success",
  "updated_range": "Signups!A2:C2",
  "message": "Data written successfully."
}

Summary Table

Best Practices

• Always use structured JSON for the data input for best results.

• Ensure you have the correct permissions to access and write to the selected Google Sheet.

• Use clear sheet and spreadsheet names to avoid confusion in multi-sheet documents.

Automate your data workflows with the GSheets node in StackAI for seamless Google Sheets integration.

What is Make?

Make (formerly Integromat) is a powerful automation platform that enables you to connect various apps and automate workflows. In StackAI, the Make node allows you to trigger webhooks, sending data to your Make scenarios and integrating StackAI with thousands of other services.

How to use it?

The Make node in StackAI is primarily used to trigger a webhook in your Make scenario. This is useful for sending data from StackAI to Make, where you can further process, route, or automate actions across your connected apps.

Example of Usage

Suppose you want to send user data from StackAI to a Make scenario for further processing. You would use the Make node to trigger a webhook with the relevant data payload.

Available Actions

1. Trigger Webhook

Description: Send a POST request to a Make webhook URL, optionally including a JSON payload. This action is commonly used to start a Make scenario from StackAI.

Inputs

• Webhook URL (Required)

  • The URL of your Make webhook.

  • Example: https://hook.us2.make.com/qee6xwvm63a8jpctrgdnxgaj6hdd3v7q

• Body (Optional)

  • The JSON data payload to send with the webhook request.

  • Example:

    Copy

    {
      "user_id": "12345",
      "event": "signup",
      "email": "[email protected]"
    }

• Description (Optional)

  • A human-readable description of the action being triggered.

  • Example: "Send new user signup data to Make"

Configurations

• Webhook URL (Required)

  • This is the only required configuration. It must be a valid Make webhook URL.

• Description (Optional)

  • Used for documentation or clarity within your workflow.

Outputs

• Status (Required)

  • Indicates if the webhook call was successful or failed.

  • Example: "success"

• Message (Required)

  • A descriptive message about the result of the webhook call.

  • Example: "Webhook triggered successfully"

• Status Code (Required)

  • The HTTP status code returned by the webhook endpoint.

  • Example: 200

• Response (Optional)

  • The JSON response data returned by the webhook, if any.

  • Example:

    Copy

    {
      "result": "ok"
    }

How to use it?

1. Obtain your Make webhook URL from your Make scenario.

2. Add the Make node to your StackAI workflow.

3. Enter the webhook URL in the configuration.

4. (Optional) Add a JSON body to send data.

5. (Optional) Add a description for clarity.

6. Connect the node to trigger the webhook as part of your workflow.

Example of Usage

• Scenario: Send new user signup data to Make for further automation.

• Webhook URL: https://hook.us2.make.com/qee6xwvm63a8jpctrgdnxgaj6hdd3v7q

• Body:

  Copy

  {
    "user_id": "12345",
    "event": "signup",
    "email": "[email protected]"
  }

• Description: "Send new user signup data to Make"

Expected Output:

• Status: "success"

• Message: "Webhook triggered successfully"

• Status Code: 200

• Response: (any data returned by your Make scenario)

Use the Make node in StackAI to seamlessly connect your AI workflows with the vast automation capabilities of Make, enabling powerful integrations and streamlined processes.

Learn how to use the Oracle node in StackAI to query Oracle databases using natural language or SQL, with clear input and output examples.

What is Oracle?

The Oracle node in StackAI allows you to query Oracle databases directly from your workflow. You can use plain English or SQL queries to retrieve data, making it easy to access and analyze your database information without writing complex code.

How to use it?

To use the Oracle node, you need to provide two required inputs:

1. Schema: Describe your database schema, including tables, columns, and data types. This helps the node understand the structure of your database.

2. Query: Enter your question or request in plain English or as a SQL statement. The node will interpret your input, generate the appropriate SQL if needed, execute it, and return the results.

Example of Usage

Suppose you have a table called Employees with columns Name (TEXT), Department (TEXT), and Salary (REAL).

• Schema (Required):

  Copy

  TABLE Employees (
    Name TEXT,
    Department TEXT,
    Salary REAL
  );

• Query (Required):

  Copy

  What is the average salary in the Sales department?

Inputs

Configurations

• No additional configurations are required for the Oracle node. All you need is the schema and the query.

Outputs

Available Actions

• Query an Oracle Database: Execute a query (in plain English or SQL) against your Oracle database and retrieve the results.

Summary Table

How to use it in StackAI

1. Add the Oracle node to your workflow.

2. Fill in the Schema with your database structure.

3. Enter your query in the Query field.

4. Connect the node to downstream nodes to use the results.

Example Output

• Query: SELECT AVG(Salary) FROM Employees WHERE Department = 'Sales';

• Results: [{"AVG(Salary)": 85000}]

This makes it easy to integrate Oracle database queries into your StackAI workflows for reporting, analytics, and automation.

Reducto is an integration that provides advanced document and data processing capabilities. It is often used for parsing, extracting, editing, and splitting documents or data files, as well as managing asynchronous jobs related to these operations. Reducto is especially useful for workflows that require automated document understanding, transformation, or extraction.

Available Actions

How to Use the Reducto Node

1. Choose the Action:

   • Select the Reducto node in your workflow and pick the action that matches your use case (e.g., Parse, Extract, Edit, Split).

2. Provide Inputs:

   • For most actions, you will need to provide a file, document, or text input. Some actions may require additional parameters (such as extraction rules, edit instructions, or split criteria).

3. Asynchronous Jobs:

   • For async actions, you will receive a job ID. Use the "Retrieve Parse Job" or similar action to check the status or get the result when processing is complete.

4. Webhooks (Optional):

   • If you want to be notified when a job is done, use the "Configure Webhook" action to set up a callback URL.

5. Connect to Output or Downstream Nodes:

   • The results from Reducto actions can be sent to Output nodes, LLM nodes, or further processing nodes in your workflow.

Example Use Cases

• Document Parsing: Automatically extract tables, text, or metadata from uploaded PDFs or Word documents.

• Data Extraction: Pull out specific fields (like names, dates, or totals) from invoices or forms.

• Document Splitting: Break up large documents into smaller, manageable sections for further analysis.

• Automated Editing: Redact sensitive information or reformat documents before sharing.

The PostgreSQL Node allows you to query a PostgreSQL database directly from your workflow. It is designed to take a user’s question (in plain English or SQL), convert it into a SQL query if needed, execute it against your connected PostgreSQL database, and return the results.

Required Inputs

1. Query (string, required)

   • This is the main input. You can enter your question in plain English (e.g., "Show me the top 10 customers by revenue") or provide a raw SQL query.

   • The node will interpret the plain English query and generate the appropriate SQL, or execute your SQL directly.

2. Schema (array of strings, optional but recommended)

   • This is where you can provide the database schema (tables, columns, types, etc.) to help the node understand your database structure.

   • Example:

     Copy

     TABLE Customers (Name TEXT, Email TEXT, Revenue REAL);
     TABLE Orders (OrderID INT, CustomerID INT, Amount REAL);

   • Providing the schema is especially helpful if you want the node to convert plain English to SQL accurately.

Output

• Query: The actual SQL query that was executed.

• Results: The results of the query, returned as an array of objects (rows).

Example Usage

• Plain English Query: Input: "What is the total revenue for the year 2024?" Output: The node will generate the SQL, run it, and return the result.

• SQL Query: Input: SELECT SUM(revenue) FROM sales WHERE year = 2024; Output: The node will execute this SQL and return the result.

How to Connect

• If you have a PostgreSQL connection ID, you can add it to the node’s configuration to connect to your specific database.

• You can connect the output of this node to downstream nodes (like an LLM for analysis, or an Output node for display).

Summary Table