MindsDB

https://docs.mindsdb.com
Admin
MindsDB is an AI Data Solution that enables humans, AI, agents, and applications to get highly...
Tokens:376,055
Snippets:3,481
Trust Score:10
Update:8 months ago
Show doc for...
Tokens:
Raw
### IfxPy Installation and Setup

Source: https://docs.mindsdb.com/data-integrations/ibm-informix

Provides instructions for installing the IfxPy driver and configuring environment variables for Linux and Windows.

```APIDOC
## IfxPy Installation and Setup

### Description
This section details the steps required to install the IfxPy Python driver and the necessary Informix ODBC driver for both Linux and Windows operating systems.

### Method
Installation and Configuration

### Endpoint
N/A

### Parameters
None

### Request Example
**Linux Installation:**
1. Download and extract the ODBC driver:
   ```bash
   cd $HOME
   mkdir Informix
   cd Informix
   mkdir -p home/informix/cli
   wget https://hcl-onedb.github.io/odbc/OneDB-Linux64-ODBC-Driver.tar
   sudo tar xvf  OneDB-Linux64-ODBC-Driver.tar -C ./home/informix/cli
   rm OneDB-Linux64-ODBC-Driver.tar
   ```
2. Add environment variables to `.bashrc`:
   ```bash
   export INFORMIXDIR=$HOME/Informix/home/informix/cli/onedb-odbc-driver
   export LD_LIBRARY_PATH=${LD_LIBRARY_PATH}${INFORMIXDIR}/lib:${INFORMIXDIR}/lib/esql:${INFORMIXDIR}/lib/cli
   ```
3. Clone, build, and install IfxPy:
   ```bash
   pip install wheel
   mkdir Temp
   cd Temp
   git clone https://github.com/OpenInformix/IfxPy.git
   cd IfxPy/IfxPy
   python setup.py bdist_wheel
   pip install --find-links=./dist IfxPy
   cd ../..
   cd ..
   rm -rf Temp
   ```

**Windows Installation:**
1. Download and extract the ODBC driver:
   ```cmd
   cd %USERPROFILE%
   mkdir Informix
   cd Informix
   mkdir  /home/informix/cli
   wget https://hcl-onedb.github.io/odbc/OneDB-Win64-ODBC-Driver.zip
   tar xvf  OneDB-Win64-ODBC-Driver.zip -C ./home/informix/cli
   del OneDB-Win64-ODBC-Driver.zip
   ```
2. Add environment variable:
   ```cmd
   set INFORMIXDIR=%USERPROFILE%\Informix\home\informix\cli\onedb-odbc-driver
   ```
3. Add `%INFORMIXDIR%\bin` to the PATH environment variable.
4. Clone, build, and install IfxPy:
   ```cmd
   pip install wheel
   mkdir Temp
   cd Temp
   git clone https://github.com/OpenInformix/IfxPy.git
   cd IfxPy/IfxPy
   python setup.py bdist_wheel
   pip install --find-links=./dist IfxPy
   cd ..
   cd ..
   cd ..
   rmdir Temp
   ```

### Response
#### Success Response (200)
Indicates successful installation and configuration.

#### Response Example
(No specific response body is detailed, success is implied by the absence of errors.)
```

--------------------------------

### Upgrade Pip, Setuptools, and Wheel

Source: https://docs.mindsdb.com/setup/self-hosted/pip/macos

Before installing MindsDB, it's recommended to upgrade pip, setuptools, and wheel to their latest versions to avoid potential dependency conflicts and ensure a smooth installation process.

```bash
pip install --upgrade pip setuptools wheel
```

--------------------------------

### Example Requirements List

Source: https://docs.mindsdb.com/integrations/ai-engines/byom

A minimal example of a requirements.txt file listing essential Python packages. This format is used by package managers like pip to install specified libraries.

```plaintext
pandas
scikit-learn
```

--------------------------------

### Start MindsDB Server

Source: https://docs.mindsdb.com/setup/self-hosted/pip/source

Starts the MindsDB server. By default, it enables the http and mysql APIs. Custom API configurations and disabling the GUI are supported.

```bash
python -m mindsdb
```

```bash
python -m mindsdb --api http,mysql,postgres
```

```bash
python -m mindsdb --no_studio
```

--------------------------------

### Install MindsDB using Makefile

Source: https://docs.mindsdb.com/contribute/install

Installs MindsDB and starts the application using provided makefile commands. This is an alternative to manual pip installation and running the script.

```bash
make install_mindsdb
make run_mindsdb
```

--------------------------------

### Install MindsDB and Development Dependencies

Source: https://docs.mindsdb.com/setup/self-hosted/pip/source

Installs MindsDB in editable mode and its development dependencies from the cloned repository. Requires navigating into the cloned directory first.

```bash
cd mindsdb
pip install -e .
pip install -r requirements/requirements-dev.txt
```

--------------------------------

### Start MindsDB Application

Source: https://docs.mindsdb.com/contribute/install

Starts the MindsDB application from the command line. Optional flags can be used to specify APIs or disable the GUI.

```bash
python -m mindsdb
# With specific APIs:
python -m mindsdb --api http,mysql
# Without GUI:
python -m mindsdb --no_studio
```

--------------------------------

### Access MindsDB Services

Source: https://docs.mindsdb.com/setup/self-hosted/pip/source

Provides the default URLs and connection strings for accessing MindsDB Studio and connecting via MySQL client after the server has started.

```bash
http://127.0.0.1:47334/
```

```bash
mysql -h 127.0.0.1 --port 3306 -u mindsdb -p
```

--------------------------------

### Install OpenAI Handler Dependencies

Source: https://docs.mindsdb.com/setup/self-hosted/docker

Example command to install the OpenAI handler dependencies for MindsDB. This command should be run inside the MindsDB Docker container's interactive shell.

```bash
pip install .[openai]
```

--------------------------------

### Example MariaDB SkySQL Data Source Configuration for MindsDB

Source: https://docs.mindsdb.com/mindsdb_sql/connect/connect-mariadb-skysql

This SQL example demonstrates how to configure a MindsDB data source for a MariaDB SkySQL service. It provides specific connection details, including host, port, database, user, and password, along with the necessary SSL certificate URL for secure communication.

```sql
CREATE DATABASE skysql_datasource
WITH ENGINE = 'MariaDB',
PARAMETERS = {
  "host": "mindsdbtest.mdb0002956.db1.skysql.net",
  "port": 5001,
  "database": "mindsdb_data",
  "user": "DB00007539",
  "password": "password",
  --- here, the SSL certificate is required
  "ssl-ca": {
    "url": "https://mindsdb-web-builds.s3.amazonaws.com/aws_skysql_chain.pem"
  }
};
```

--------------------------------

### Create and Activate Python Virtual Environment

Source: https://docs.mindsdb.com/setup/self-hosted/pip/macos

This snippet demonstrates how to create a new Python virtual environment named 'mindsdb' and then activate it. This is a standard practice to isolate project dependencies.

```bash
python -m venv mindsdb
source mindsdb/bin/activate
```

--------------------------------

### Install IfxPy Driver for Informix on Linux

Source: https://docs.mindsdb.com/integrations/data-integrations/ibm-informix

These bash commands install the IfxPy driver and its dependencies on a Linux system. It involves downloading the ODBC driver, setting environment variables, cloning the IfxPy repository, building a wheel, and installing it.

```bash
cd $HOME
mkdir Informix
cd Informix
mkdir -p home/informix/cli
wget https://hcl-onedb.github.io/odbc/OneDB-Linux64-ODBC-Driver.tar
sudo tar xvf  OneDB-Linux64-ODBC-Driver.tar -C ./home/informix/cli
rm OneDB-Linux64-ODBC-Driver.tar
```

```bash
export INFORMIXDIR=$HOME/Informix/home/informix/cli/onedb-odbc-driver
export LD_LIBRARY_PATH=${LD_LIBRARY_PATH}${INFORMIXDIR}/lib:${INFORMIXDIR}/lib/esql:${INFORMIXDIR}/lib/cli
```

```bash
pip install wheel
mkdir Temp
cd Temp
git clone https://github.com/OpenInformix/IfxPy.git
cd IfxPy/IfxPy
python setup.py bdist_wheel
pip install --find-links=./dist IfxPy
cd ..
cd ..
cd ..
rm -rf Temp
```

--------------------------------

### Check Python and Pip Versions

Source: https://docs.mindsdb.com/setup/self-hosted/pip/source

Commands to verify the installed Python and pip versions, which are crucial for successful MindsDB installation.

```bash
pip --version
python --version
```

--------------------------------

### Install MindsDB Handler Dependencies

Source: https://docs.mindsdb.com/setup/self-hosted/pip/source

Installs dependencies for specific MindsDB data or ML integrations. Replace 'handler_name' with the actual handler you need.

```bash
pip install mindsdb[handler_name]
```

--------------------------------

### Install IfxPy Driver and ODBC Driver on Linux

Source: https://docs.mindsdb.com/data-integrations/ibm-informix

This section provides shell commands for installing the IfxPy driver and the Informix ODBC driver on a Linux system. It includes downloading and extracting the ODBC driver, setting environment variables in `.bashrc`, and cloning, building, and installing the IfxPy Python package.

```bash
cd $HOME
mkdir Informix
cd Informix
mkdir -p home/informix/cli
wget https://hcl-onedb.github.io/odbc/OneDB-Linux64-ODBC-Driver.tar
sudo tar xvf  OneDB-Linux64-ODBC-Driver.tar -C ./home/informix/cli
rm OneDB-Linux64-ODBC-Driver.tar
```

```bash
export INFORMIXDIR=$HOME/Informix/home/informix/cli/onedb-odbc-driver
export LD_LIBRARY_PATH=${LD_LIBRARY_PATH}${INFORMIXDIR}/lib:${INFORMIXDIR}/lib/esql:${INFORMIXDIR}/lib/cli}
```

```bash
pip install wheel
mkdir Temp
cd Temp
git clone https://github.com/OpenInformix/IfxPy.git
cd IfxPy/IfxPy
python setup.py bdist_wheel
pip install --find-links=./dist IfxPy
cd ..
cd ..
cd ..
rm -rf Temp
```

--------------------------------

### Install IfxPy Driver and ODBC Driver on Windows

Source: https://docs.mindsdb.com/data-integrations/ibm-informix

This section provides shell commands for installing the IfxPy driver and the Informix ODBC driver on a Windows system. It includes downloading and extracting the ODBC driver, setting environment variables, and cloning, building, and installing the IfxPy Python package.

```bash
cd $HOME
mkdir Informix
cd Informix
mkdir  /home/informix/cli
wget https://hcl-onedb.github.io/odbc/OneDB-Win64-ODBC-Driver.zip
tar xvf  OneDB-Win64-ODBC-Driver.zip -C ./home/informix/cli
del OneDB-Win64-ODBC-Driver.zip
```

```bash
set INFORMIXDIR=$HOME/Informix/home/informix/cli/onedb-odbc-driver
```

```bash
pip install wheel
mkdir Temp
cd Temp
git clone https://github.com/OpenInformix/IfxPy.git
cd IfxPy/IfxPy
python setup.py bdist_wheel
pip install --find-links=./dist IfxPy
cd ..
cd ..
cd ..
rmdir Temp
```

--------------------------------

### Start MindsDB with Extended Configuration (Docker & Python)

Source: https://docs.mindsdb.com/setup/custom-config

Demonstrates how to launch MindsDB with a custom configuration file using both Docker and Python. This allows for flexible setup of APIs and storage locations. Ensure MindsDB is installed locally via Docker or PyPI before proceeding.

```bash
docker run --name mindsdb_container -e MINDSDB_CONFIG_PATH=/Users/username/path/config.json -e MINDSDB_APIS=http,mysql -p 47334:47334 -p 47335:47335 mindsdb/mindsdb
```

```bash
python -m mindsdb --api=http,mysql --config=/path-to-the-extended-config-file/config.json
```

--------------------------------

### Query Knowledge Base in MindsDB

Source: https://docs.mindsdb.com/quickstart-tutorial

Queries the 'my_kb' knowledge base to search for specific content. Demonstrates two example queries: one for exact content matching and another for filtering based on a condition within the content. This showcases how to retrieve information from the unified data.

```sql
SELECT * FROM my_kb WHERE content = 'what is MindsDB';

SELECT * FROM my_kb WHERE content = 'rental price lower than 2000';
```

--------------------------------

### Connect to Snowflake Database (Example)

Source: https://docs.mindsdb.com/data-integrations/all-data-integrations

This example provides a practical setup for connecting to a Snowflake instance via MindsDB. It specifies the account hostname, port, database, user credentials, account identifier, and warehouse.

```sql
CREATE DATABASE snowflake_datasource
WITH ENGINE = 'snowflake',
PARAMETERS = {
  "host": "account_name.snowflakecomputing.com",
  "port": 443,
  "database": "snowflake",
  "user": "user",
  "password": "password",
  "account": "account_name",
  "schema": "public",
  "protocol": "https",
  "warehouse": "warehouse"
};

```

--------------------------------

### Start MindsDB Docker Container

Source: https://docs.mindsdb.com/setup/self-hosted/docker

Command to start a pre-existing MindsDB Docker container. Ensure the container name 'mindsdb_container' is correct or find it using 'docker ps'.

```bash
docker start mindsdb_container
```

--------------------------------

### Connect to SQLite Database (Example)

Source: https://docs.mindsdb.com/data-integrations/all-data-integrations

This example provides a concrete instance of creating a SQLite data handler in MindsDB, specifying the path to an example database file named 'example.db'.

```sql
CREATE DATABASE sqlite_datasource
WITH ENGINE = 'sqlite',
PARAMETERS = {
  "db_file": "example.db"
};

```

--------------------------------

### Install MindsDB Python SDK using pip

Source: https://docs.mindsdb.com/sdks/python/installation

Installs the MindsDB Python SDK using the pip package manager. This is the simplest way to get started with the SDK.

```bash
pip install mindsdb_sdk
```

--------------------------------

### Install libomp for macOS

Source: https://docs.mindsdb.com/setup/self-hosted/pip/macos

This command installs the libomp library using Homebrew, which is sometimes required to resolve 'OSError: dlopen Library not loaded 'libomp.dylib'' errors on macOS.

```bash
brew install libomp
export LDFLAGS="-L/usr/local/opt/libomp/lib"
export CPPFLAGS="-I/usr/local/opt/libomp/include"
```

--------------------------------

### Create and Use Google Langchain Model

Source: https://docs.mindsdb.com/integrations/ai-engines/langchain

This example shows the complete process of creating a Langchain ML engine for Google and then creating a Google language model. It concludes with a query to ask the model a question. Ensure you have the necessary API keys and the Langchain engine is properly set up.

```sql
CREATE ML_ENGINE langchain_engine_google
FROM langchain;

CREATE MODEL langchain_google_model
PREDICT answer 
USING
     engine = 'langchain_engine_google',
     provider = 'google',
     google_api_key = 'api-key-value',
     model_name = 'gemini-1.5-flash',
     mode = 'conversational',
     user_column = 'question',
     assistant_column = 'answer',
     verbose = True,
     prompt_template = 'Answer the users input in a helpful way: {{question}}',
     max_tokens = 4096;

SELECT question, answer
FROM langchain_google_model
WHERE question = 'How many planets are in the solar system?';
```

--------------------------------

### Install MindsDB using Pip

Source: https://docs.mindsdb.com/setup/self-hosted/pip/macos

This command installs the MindsDB package using pip within an activated virtual environment. Ensure Python and pip versions meet the requirements specified in the documentation.

```bash
pip install mindsdb
```

--------------------------------

### Create and Activate Python venv for MindsDB

Source: https://docs.mindsdb.com/setup/self-hosted/pip/windows

This snippet demonstrates how to create a new virtual environment named 'mindsdb' using Python's venv module and then activate it on a Windows system. This is a prerequisite for installing MindsDB to manage dependencies effectively.

```bash
py -m venv mindsdb
.
\mindsdb\Scripts\activate.bat
```

--------------------------------

### Connect to Handler in Python

Source: https://docs.mindsdb.com/contribute/app-handlers

Sets up any necessary connections for the handler. This method should attempt to establish a connection and update the handler's connection status.

```python
def connect(self) -> HandlerStatusResponse:
    """ Set up any connections required by the handler
    Should return output of check_connection() method after attempting
    connection. Should switch self.is_connected.
    Returns:
        HandlerStatusResponse
    """

```

--------------------------------

### Create and Activate Conda Virtual Environment

Source: https://docs.mindsdb.com/setup/self-hosted/pip/macos

This snippet shows how to create a new Conda virtual environment named 'mindsdb' and then activate it. This is an alternative to Python's venv for managing environments.

```bash
conda create -n mindsdb
conda activate mindsdb
```

--------------------------------

### SQL Example for Batch Predictions

Source: https://docs.mindsdb.com/mindsdb_sql/sql/get-batch-predictions

This SQL example illustrates how to perform bulk predictions for 'rental_price' using the 'home_rentals_model' joined with the 'home_rentals' data source table. It shows a practical application of the syntax for predicting rental prices based on property features. The output displays the original data alongside the predicted rental prices.

```sql
SELECT t.sqft, t.location, t.neighborhood, t.days_on_market, t.rental_price AS real_price,
       m.rental_price AS predicted_rental_price
FROM example_db.demo_data.home_rentals AS t
JOIN mindsdb.home_rentals_model AS m
LIMIT 5;
```

--------------------------------

### Example: Creating and Managing a MindsDB Project

Source: https://docs.mindsdb.com/sql/project

This example demonstrates the full lifecycle of a MindsDB project, including creation, verification, adding objects (model and view), and the process of dropping the project after removing its contents.

```sql
-- Create a project
CREATE PROJECT my_project;

-- Verify project creation
SHOW FULL DATABASES;

-- Create a model within the project
CREATE MODEL my_project.my_model
FROM example_db
    (SELECT * FROM demo_data.home_rentals)
PREDICT rental_price;

-- Create a view within the project
CREATE VIEW my_project.my_view (
    SELECT * 
    FROM example_db.demo_data.home_rentals
);

-- Show tables within the project
SHOW TABLES FROM my_project;

-- Attempt to drop the project (will fail if objects exist)
DROP PROJECT my_project;

-- Drop objects within the project
DROP MODEL my_project.my_model;
DROP VIEW my_project.my_view;

-- Drop the project after removing objects
DROP PROJECT my_project;
```

--------------------------------

### Setup OpenAI ML Engine

Source: https://docs.mindsdb.com/integrations/ai-engines/openai

This section details how to create an AI engine using the OpenAI handler in MindsDB.

```APIDOC
## POST /api/ml_engines

### Description
Creates an AI engine using the OpenAI handler.

### Method
POST

### Endpoint
/api/ml_engines

### Parameters
#### Request Body
- **name** (string) - Required - The name for the ML engine.
- **engine_type** (string) - Required - Must be 'openai'.
- **credentials** (object) - Required - Contains the OpenAI API key.
  - **openai_api_key** (string) - Required - Your OpenAI API key.

### Request Example
```json
{
  "name": "openai_engine",
  "engine_type": "openai",
  "credentials": {
    "openai_api_key": "api-key-value"
  }
}
```

### Response
#### Success Response (200)
- **message** (string) - Confirmation message of successful engine creation.

#### Response Example
```json
{
  "message": "ML Engine openai_engine created successfully"
}
```
```

--------------------------------

### Requirements File Format

Source: https://docs.mindsdb.com/integrations/ai-engines/byom

This is a sample format for a requirements.txt file, used to list project dependencies and their version constraints. It supports exact version matching, minimum version requirements, and version ranges.

```plaintext
dependency_package_1 == version
dependency_package_2 >= version
dependency_package_3 >= version, < version
...
```

--------------------------------

### Create and Query MindsDB Knowledge Base (SQL)

Source: https://docs.mindsdb.com/mindsdb_sql/knowledge_bases/examples

Demonstrates the SQL syntax for creating a knowledge base, inserting data from a sample database, and querying the knowledge base with specific criteria. It includes setting up embedding and reranking models, defining metadata and content columns, and performing relevance-based searches.

```sql
CREATE DATABASE sample_data
WITH ENGINE = 'postgres',
PARAMETERS = {
    "user": "demo_user",
    "password": "demo_password",
    "host": "samples.mindsdb.com",
    "port": "5432",
    "database": "demo",
    "schema": "demo_data"
};

SELECT * FROM sample_data.orders;
```

```sql
CREATE KNOWLEDGE_BASE my_kb
USING
    embedding_model = {
        "provider": "openai",
        "model_name" : "text-embedding-3-large",
        "api_key": "sk-abc123"
    },
    reranking_model = {
        "provider": "openai",
        "model_name": "gpt-4o",
        "api_key": "sk-abc123"
    },
    metadata_columns = ['product'],
    content_columns = ['notes'],
    id_column = 'order_id';
```

```sql
INSERT INTO my_kb
SELECT order_id, product, notes
FROM sample_data.orders;
```

```sql
SELECT *
FROM my_kb
WHERE product = 'Wireless Mouse'
AND content = 'color'
AND relevance > 0.5;
```

--------------------------------

### Create LiteLLM Model with Langchain Engine

Source: https://docs.mindsdb.com/integrations/ai-engines/langchain

This snippet demonstrates how to create a language model using the Langchain engine with the LiteLLM provider. It specifies parameters like API key, model name, conversational mode, and prompt template. Ensure you have the LiteLLM library installed and a valid API key.

```sql
CREATE MODEL langchain_litellm_model
PREDICT answer
USING
     engine = 'langchain_engine',
     provider = 'litellm',
     litellm_api_key = 'api-key-value',
     model_name = 'gpt-4',
     mode = 'conversational',
     user_column = 'question',
     assistant_column = 'answer',
     base_url = 'https://ai.dev.mindsdb.com',
     verbose = True,
     prompt_template = 'Answer the users input in a helpful way: {{question}}',
     max_tokens = 4096;
```

--------------------------------

### Example: Querying Home Rental Data (SQL)

Source: https://docs.mindsdb.com/mindsdb_sql/sql/api/select-files

An example demonstrating how to query a specific file named 'home_rentals' and limit the results to the first 10 rows. This is useful for previewing data before further analysis.

```sql
SELECT *
FROM files.home_rentals
LIMIT 10;
```

--------------------------------

### Check Pip Version

Source: https://docs.mindsdb.com/setup/self-hosted/pip/linux

This command displays the currently installed pip version. MindsDB requires pip version 20.3 or higher for proper installation.

```bash
pip --version
```

--------------------------------

### MindsDB Prompt Completion with OpenAI Engine

Source: https://docs.mindsdb.com/integrations/ai-engines/openai

Shows how to use a pre-existing MindsDB model with the `openai_engine` for prompt completion. This example overrides parameters like `prompt_template`, `max_tokens`, and `temperature` at prediction time.

```sql
SELECT instruction, answer
FROM openai_model
WHERE instruction = 'Speculate extensively'
USING
    prompt_template = '{{instruction}}. What does Tom Hanks like?',
    max_tokens = 100,
    temperature = 0.5;
```

--------------------------------

### Stop and Start MindsDB Docker Container

Source: https://docs.mindsdb.com/setup/self-hosted/docker

Commands to manage the lifecycle of the MindsDB Docker container. 'docker stop' halts the running container, while 'docker start' resumes a stopped container, preserving its state and installed dependencies. Note that containers also shut down when the host machine powers off.

```bash
docker stop mindsdb_container
```

```bash
docker start mindsdb_container
```

--------------------------------

### Insert Data using Partitions

Source: https://docs.mindsdb.com/mindsdb_sql/knowledge_bases/insert_data

Optimize data insertion performance by setting up partitions and threads to insert data in parallel. Track, cancel, and resume the insertion process.

```APIDOC
## POST /INSERT INTO knowledge_base

### Description
Inserts data into the knowledge base using partitions and threads for parallel processing. Allows for tracking, canceling, and resuming the insertion process.

### Method
INSERT INTO

### Endpoint
`INSERT INTO <knowledge_base_name> SELECT ... USING ...`

### Parameters
#### Query Parameters
- **batch_size** (integer) - Optional - Defines the number of rows fetched per iteration. Defaults to 1000.
- **threads** (integer or boolean) - Optional - Defines threads for running partitions. Can be a number (e.g., `10`), `true` to enable, or `false` to disable. Threads are used automatically if the ML task queue is enabled.
- **track_column** (string) - Optional - Defines the column used for sorting data before partitioning.
- **error** (string) - Optional - Defines error processing options. Available values: `raise` (default) or `skip`.

### Request Example
```sql
INSERT INTO my_kb
SELECT order_id, product, notes
FROM sample_data.orders
USING
    batch_size = 200,
    track_column = order_id,
    threads = 10,
    error = 'skip';
```

### Response
#### Success Response (200)
Data is inserted into the knowledge base.

#### Response Example
(No specific response body for INSERT statement, progress can be monitored via `information_schema.queries`)

### Related Operations
#### View Insertion Progress
```sql
SELECT * FROM information_schema.queries;
```

#### Cancel Insertion Process
```sql
SELECT query_cancel(<process_id>);
```

#### Resume Insertion Process
```sql
SELECT query_resume(<process_id>);
```
```

--------------------------------

### List Agents using cURL

Source: https://docs.mindsdb.com/rest/agents/list

This example demonstrates how to list all agents in a project using the cURL command-line tool. It sends a GET request to the specified API endpoint.

```shell
curl --request GET \
  --url http://127.0.0.1:47334/api/projects/mindsdb/agents
```

--------------------------------

### Insert Data with Partitions and Threads in SQL

Source: https://docs.mindsdb.com/mindsdb_sql/knowledge_bases/insert_data

This SQL statement demonstrates how to insert data into a knowledge base using partitions and threads for parallel processing. It includes parameters for batch size, tracking column, number of threads, and error handling. The default batch size is 1000, and error handling defaults to 'raise'.

```sql
INSERT INTO my_kb
SELECT order_id, product, notes
FROM sample_data.orders
USING
    batch_size = 200,
    track_column = order_id,
    threads = 10,
    error = 'skip';
```

--------------------------------

### Query an Agent in MindsDB

Source: https://docs.mindsdb.com/quickstart-tutorial

This SQL snippet shows how to query a previously created MindsDB agent. By setting the 'question' parameter, you can ask natural language questions about the data the agent has access to.

```sql
SELECT *
FROM my_agent
WHERE question = 'what is MindsDB?';
```

--------------------------------

### Query MindsDB Model for Predictions

Source: https://docs.mindsdb.com/sql/tutorials/hugging-face-examples

This snippet demonstrates how to query a trained MindsDB model to get predictions. It selects all columns from the model and provides a text input to predict its classification.

```sql
SELECT *
FROM mindsdb.hf_industry
WHERE text = 'Low latency is one of our best cloud features';
```

--------------------------------

### Create and Activate Virtual Environment

Source: https://docs.mindsdb.com/setup/self-hosted/pip/source

Creates a Python virtual environment named 'mindsdb-venv' and activates it. This isolates project dependencies.

```bash
python -m venv mindsdb-venv
source mindsdb-venv/bin/activate
```

--------------------------------

### Create Oracle Database Connection (SQL)

Source: https://docs.mindsdb.com/integrations/data-integrations/all-data-integrations

SQL template for establishing a connection to an Oracle database. Key parameters include host, port, SID, user, and password. An example demonstrates a complete connection setup.

```sql
CREATE DATABASE oracle_datasource
WITH ENGINE = 'oracle',
PARAMETERS = {
  "host": " ",
  "port": ,
  "sid": " ",
  "user": " ",
  "password": " "
};
```

```sql
CREATE DATABASE oracle_datasource
WITH ENGINE = 'oracle',
PARAMETERS = {
  "host": "127.0.0.1",
  "port": 1521,
  "sid": "ORCL",
  "user": "sys",
  "password": "password"
};
```

--------------------------------

### Connect to SingleStore Database (Example)

Source: https://docs.mindsdb.com/data-integrations/all-data-integrations

This example demonstrates a concrete configuration for a SingleStore data handler in MindsDB, using localhost and default credentials. It includes host, port, database, user, and password.

```sql
CREATE DATABASE singlestore_datasource
WITH ENGINE = 'singlestore',
PARAMETERS = {
  "host": "127.0.0.1",
  "port": 3306,
  "database": "singlestore",
  "user": "root",
  "password": "password"
};

```

--------------------------------

### Create Knowledge Base in MindsDB

Source: https://docs.mindsdb.com/quickstart-tutorial

Creates a knowledge base named 'my_kb' using specified embedding and reranking models from OpenAI. It defines the content columns for the data to be stored. This is a prerequisite for unifying and querying unstructured data.

```sql
CREATE KNOWLEDGE_BASE my_kb
USING
    embedding_model = {
        "provider": "openai",
        "model_name" : "text-embedding-3-large",
        "api_key": "your-openai-api-key"
    },
    reranking_model = {
        "provider": "openai",
        "model_name": "gpt-4o",
        "api_key": "your-openai-api-key"
    },
    content_columns = ['content'];
```

--------------------------------

### Connect MySQL Database to MindsDB

Source: https://docs.mindsdb.com/quickstart-tutorial

Establishes a connection to a MySQL database using the CREATE DATABASE statement. Requires database credentials and connection parameters. This allows MindsDB to access and query data from the specified MySQL instance.

```sql
CREATE DATABASE mysql_demo_db
WITH ENGINE = 'mysql',
PARAMETERS = {
    "user": "user",
    "password": "MindsDBUser123!",
    "host": "samples.mindsdb.com",
    "port": "3306",
    "database": "public"
};
```

--------------------------------

### CREATE INDEX ON KNOWLEDGE_BASE Syntax

Source: https://docs.mindsdb.com/mindsdb_sql/knowledge_bases/insert_data

Explains how to create an index on a knowledge base to improve search performance. This is applicable for PGVector-based knowledge bases.

```APIDOC
## CREATE INDEX ON KNOWLEDGE_BASE Syntax

Users can create index on the knowledge base to speed up the search operations.

```sql
CREATE INDEX ON KNOWLEDGE_BASE my_kb;
```

<Warning>
  Note that this feature works only when PGVector is used as the [storage of the knowledge base](/mindsdb_sql/knowledge_bases/create#storage), as ChromaDB provides the index features by default.
</Warning>

Upon executing this statement, an index is created on the knowledge base's underlying vector store. This is essentially a database index created on the vector database.

Note that having an index on the knowledge base may reduce the speed of the insert operations. Therefore, it is recommended to insert bulk data into the knowledge base before creating an index. The index improves performance of querying the knowledge base, while it may slow down subsequent data inserts.
```

--------------------------------

### Example Chatbot Creation

Source: https://docs.mindsdb.com/mindsdb_sql/agents/chatbot

This example demonstrates the creation of a chatbot named 'text_to_sql_chatbot' using a pre-configured Slack database connection and a text-to-SQL agent. It also sets the chatbot to be running upon creation.

```sql
CREATE CHATBOT text_to_sql_chatbot
USING
    database = 'my_slack',        -- this must be created with CREATE DATABASE
    agent = 'text_to_sql_agent',  -- this must be created with CREATE AGENT
    is_running = true;
```

--------------------------------

### Query Text Classification Model for Predictions

Source: https://docs.mindsdb.com/sql/tutorials/hugging-face-examples

This SQL query is used to get predictions from a text classification model. It takes a text input and returns the predicted label along with explanation and the original text.

```sql
SELECT *
FROM mindsdb.hf_spam
WHERE text = 'I like you. I love you.';
```

--------------------------------

### List Knowledge Bases Response (JSON)

Source: https://docs.mindsdb.com/rest/knowledge_bases/list

This is an example JSON response for the GET /api/projects/{project_name}/knowledge_bases endpoint. It details the structure of a knowledge base object, including its ID, name, project association, vector database configuration, and timestamps.

```json
[
  {
    "id": 1,
    "name": "my_kb",
    "project_id": 1,
    "vector_database": "my_kb_chromadb",
    "vector_database_table": "default_collection",
    "updated_at": "2025-06-25 13:04:01.864625",
    "created_at": "2025-06-25 13:04:01.864624",
    "query_id": null,
    "embedding_model": null,
    "reranking_model": null,
    "metadata_columns": null,
    "content_columns": null,
    "id_column": null,
    "params": {
      "created_embedding_model": "kb_embedding_my_kb",
      "default_vector_storage": "my_kb_chromadb"
    },
    "project_name": "mindsdb"
  }
]
```

--------------------------------

### Clone MindsDB Repository

Source: https://docs.mindsdb.com/setup/self-hosted/pip/source

Clones the MindsDB source code from GitHub to your local machine. This is the first step for deploying MindsDB from source.

```bash
git clone https://github.com/mindsdb/mindsdb.git
```

--------------------------------

### Query Data from Connected MySQL Database

Source: https://docs.mindsdb.com/quickstart-tutorial

Retrieves data from a connected MySQL database using a SELECT statement. This snippet demonstrates how to query a specific table and limit the results. It's used to preview data after establishing a database connection.

```sql
SELECT *
FROM mysql_demo_db.home_rentals
LIMIT 3;
```

--------------------------------

### Add MindsDB IPs to MariaDB SkySQL Allowlist

Source: https://docs.mindsdb.com/connect/connect-mariadb-skysql

These IP addresses need to be added to your MariaDB SkySQL service's security settings to allow MindsDB to connect. This is a crucial step for establishing communication between the two services.

```text
18.220.205.95
3.19.152.46
52.14.91.162
```

--------------------------------

### List Projects with SQL

Source: https://docs.mindsdb.com/mindsdb_sql/sql/list-projects

The `SHOW DATABASES` command lists all available data sources and projects. The `WHERE` clause can be used to filter these projects by type. The `FULL` keyword provides additional information.

```sql
SHOW DATABASES
WHERE type = 'project';
```

```sql
SHOW FULL DATABASES
WHERE type = 'project';
```

--------------------------------

### Start Ngrok Tunnel for TCP

Source: https://docs.mindsdb.com/mindsdb_sql/sql/create/database

Initiates an Ngrok TCP tunnel to expose a local port to the internet. Replace 'port-number' with the actual port your local database is running on. This command requires Ngrok to be installed and configured with an auth token.

```bash
ngrok tcp port-number
```

--------------------------------

### Connect MySQL Data Source Example

Source: https://docs.mindsdb.com/mindsdb_sql/sql/create/database

Illustrates how to connect to a MySQL database using the CREATE DATABASE command. It specifies the engine as 'mariadb' and provides necessary connection parameters like user, port, password, host, and database name.

```sql
CREATE DATABASE mysql_datasource
WITH ENGINE = 'mariadb',
PARAMETERS = {
  "user": "root",
  "port": 3307,
  "password": "password",
  "host": "127.0.0.1",
  "database": "my_database"
};
```

--------------------------------

### Query Hugging Face Sentiment Model Predictions

Source: https://docs.mindsdb.com/sql/tutorials/hugging-face-examples

Queries a trained MindsDB Hugging Face sentiment model to get predictions for a given text input. The output includes the predicted sentiment ('PRED') and an explanation of the prediction probabilities.

```sql
SELECT *
FROM mindsdb.hf_sentiment
WHERE text = 'I like you. I love you.';
```

--------------------------------

### List Linked Databases Example

Source: https://docs.mindsdb.com/mindsdb_sql/sql/create/database

Demonstrates the SQL command to list all databases that have been successfully linked to MindsDB. The output shows the names of the connected data sources.

```sql
SHOW DATABASES;
```

--------------------------------

### Create MindsDB Data Source for MariaDB SkySQL

Source: https://docs.mindsdb.com/connect/connect-mariadb-skysql

This SQL template is used within the MindsDB Editor to create a new data source connection to your MariaDB SkySQL service. It requires details such as host, port, credentials, and SSL configuration.

```sql
CREATE DATABASE maria_datasource            --- display name for the database
WITH ENGINE = 'MariaDB',                      --- name of the MindsDB handler
PARAMETERS = {
  "host": " ",                              --- host IP address or URL
  "port": ,                                 --- port used to make TCP/IP connection
  "database": " ",                          --- database name
  "user": " ",                              --- database user
  "password": " ",                          --- database password
  "ssl": True/False,                        --- optional, the `ssl` parameter value indicates whether SSL is enabled (`True`) or disabled (`False`)
  "ssl_ca": {
    "path": " "                                 --- either "path" or "url"
  },
  "ssl_cert": {
    "url": " "                                  --- either "path" or "url"
  },
  "ssl_key": {
    "path": " "                                 --- either "path" or "url"
  }
};
```
Tokens:
Raw