SeaTable AI Integration¶

6.0

SeaTable AI is a SeaTable extension that integrates AI functionality into SeaTable. Deploying SeaTable AI allows users to execute AI-based automation steps within SeaTable.

At the time of writing, the following types of automation steps are supported:

Summarize
Classify
OCR (Optical character recognition)
Extract
Custom for individual use cases

Deployment¶

SeaTable AI Is Not an AI Engine

The SeaTable AI container does not provide any AI functionality by itself. It only manages the connection between SeaTable and an external large language model (LLM) service. You can connect it to a commercial provider (e.g., OpenAI, Deepseek) or to a self-hosted LLM running on your own infrastructure.

The easiest way to deploy SeaTable AI is to deploy it on the same host as SeaTable Server. A standalone deployment (on a separate host or virtual machine) is explained here.

Amend the .env file¶

To install SeaTable AI, include seatable-ai.yml in the COMPOSE_FILE variable within your .env file. This instructs Docker-Compose to include the seatable-ai service.

Simply copy and paste () the following code into your command line:

sed -i "s/COMPOSE_FILE='\(.*\)'/COMPOSE_FILE='\1,seatable-ai.yml'/" /opt/seatable-compose/.env

Then add SeaTable AI server configurations in .env:

ENABLE_SEATABLE_AI=true

LLM Provider Configuration¶

SeaTable AI will use AI functions in conjunction with a Large Language Model (LLM) service.

Supported LLM Providers

SeaTable AI supports a wide variety of LLM providers through LiteLLM as well as any LLM services with OpenAI-compatible endpoints. Please refer to LiteLLM's documentation in case you run into issues while trying to use a specific provider.

Model Selection

In order to ensure the efficient use of SeaTable AI features, you need to select a large, multimodal model. This requires the chosen model to support image input and recognition (e.g. for running OCR as part of automations).

The following section showcases the required configuration settings for the most popular hosted LLM services.

The configuration approach depends on your SeaTable version:

SeaTable v6.0 + v6.1¶

For SeaTable v6.0 and v6.1, the LLM provider is configured inside the .env file:

OpenAIDeepseekAzure OpenAIGemini / Google AI StudioOllamaHuggingFaceSelf-Hosted Proxy ServerOther

SEATABLE_AI_LLM_TYPE=openai
SEATABLE_AI_LLM_KEY=<your openai LLM access key>
SEATABLE_AI_LLM_MODEL=gpt-4o-mini # recommended

SEATABLE_AI_LLM_TYPE=deepseek
SEATABLE_AI_LLM_KEY=<your LLM access key>
SEATABLE_AI_LLM_MODEL=deepseek-chat # recommended

SEATABLE_AI_LLM_TYPE=azure
SEATABLE_AI_LLM_URL= # your deployment url, leave blank to use default endpoint
SEATABLE_AI_LLM_KEY=<your API key>
SEATABLE_AI_LLM_MODEL=<your deployment name>

SEATABLE_AI_LLM_TYPE=gemini
# Leave SEATABLE_AI_LLM_URL unset
SEATABLE_AI_LLM_KEY=<your LLM access key>
SEATABLE_AI_LLM_MODEL=<your model-id>

SEATABLE_AI_LLM_TYPE=ollama
SEATABLE_AI_LLM_URL=<your LLM endpoint>
SEATABLE_AI_LLM_KEY=<your LLM access key>
SEATABLE_AI_LLM_MODEL=<your model-id>

SEATABLE_AI_LLM_TYPE=huggingface
SEATABLE_AI_LLM_URL=<your huggingface API endpoint>
SEATABLE_AI_LLM_KEY=<your huggingface API key>
SEATABLE_AI_LLM_MODEL=<model provider>/<model-id>

SEATABLE_AI_LLM_TYPE=proxy
SEATABLE_AI_LLM_URL=<your proxy url>
SEATABLE_AI_LLM_KEY=<your proxy virtual key> # optional
SEATABLE_AI_LLM_MODEL=<model-id>

If you are using an LLM service with OpenAI-compatible endpoints, you should set SEATABLE_AI_LLM_TYPE to other or openai, and set other LLM configuration settings as necessary:

SEATABLE_AI_LLM_TYPE=...
SEATABLE_AI_LLM_URL=...
SEATABLE_AI_LLM_KEY=...
SEATABLE_AI_LLM_MODEL=...

SeaTable v6.2+¶

SeaTable v6.2 and later versions require you to configure the LLM provider inside the /opt/seatable-server/seatable/conf/seatable_config.yaml file on the host. The LLM provider configuration is now placed inside a .yaml file to allow configuring different providers/models for different AI functions. If the file does not exist yet, simply create it.

OpenAIDeepseekAzure OpenAIGemini / Google AI StudioOllamaHuggingFaceSelf-Hosted Proxy ServerOther

global:
  LLM_MODELS:
    - type: openai
      key: <your openai LLM access key>
      model: gpt-4o-mini # recommended

global:
  LLM_MODELS:
    - type: deepseek
      key: <your LLM access key>
      model: deepseek-chat # recommended

global:
  LLM_MODELS:
    - type: azure
      url: # your deployment url, leave blank to use default endpoint
      key: <your API key>
      model: <your deployment name>

global:
  LLM_MODELS:
    - type: gemini
      key: <your LLM access key>
      model: <your model-id>

global:
  LLM_MODELS:
    - type: ollama
      url: <your LLM endpoint>
      key: <your LLM access key>
      model: <your model-id>

global:
  LLM_MODELS:
    - type: huggingface
      url: <your huggingface API endpoint>
      key: <your huggingface API key>
      model: <model provider>/<model-id>

global:
  LLM_MODELS:
    - type: proxy
      url: <your proxy url>
      key: <your proxy virtual key> # optional
      model: <model-id>

If you are using an LLM service with OpenAI-compatible endpoints, you should set type to other or openai, and set other LLM configuration settings as necessary:

global:
  LLM_MODELS:
    - type: ...
      url: ...
      key: ...
      model: ...

Configuration changes require a container restart

The seatable-ai container will not be automatically restarted when running docker compose up -d if you've only made changes to the seatable_config.yaml config file. Docker Compose does not watch files inside volume mounts, therefore a manual recreation of the container (via --force-recreate) is necessary whenever you're making configuration changes:

cd /opt/seatable-compose
docker compose up -d --force-recreate seatable-ai

Multiple LLM Providers¶

6.2

Since version 6.2, SeaTable AI supports the configuration of multiple LLM providers for different purposes. Simply configure multiple providers under global.LLM_MODELS within seatable_config.yaml.

The following seatable_config.yaml example configures two LLM providers:

A self-hosted model (using vLLM) with tier: low
A hosted Mistral model is used for more complex tasks (tier: high)

The second block (seatable-ai.FEATURE_MODEL_TIER) is used to configure the required tier level for each AI functionality. In this example, the configuration ensures that the self-hosted model is used for OCR, text summarization, classification and extraction tasks, while the cloud-hosted Mistral model will be used for custom prompts.

global:
  LLM_MODELS:
    - type: hosted_vllm
      model: <model>
      tier: low
      url: <url>
      key: <key>
    - type: mistral
      model: <model>
      tier: high
      key: <key>

seatable-ai:
  FEATURE_MODEL_TIER:
    ocr: low
    text_summarize: low
    classification: low
    extract: low
    custom: high

Allowed values for tier

tier supports the following values: low, medium and high

LLM Timeout Configuration (Optional)¶

6.1

You can configure the communication timeout with the LLM service by specifying SEATABLE_AI_LLM_TIMEOUT in .env (the default is 180 seconds):

SEATABLE_AI_LLM_TIMEOUT=180

Download SeaTable AI image and restart¶

One more step is necessary to download the SeaTable AI image and restart the SeaTable service:

cd /opt/seatable-compose
docker compose up -d

Now SeaTable AI can be used.