Agent

With MindsDB, you can create and deploy AI agents that comprise AI models and customizable skills such as knowledge bases and text-to-SQL.

AI agents use a conversational model (like OpenAI) from LangChain utilizing tools as skills to respond to user input. Users can customize AI agents with their own prompts to fit their use cases.

A chatbot can be thought of as an agent connected to some messaging interface.

​

How to work with AI agents

​

Create skills

Start by setting up the skills. Here is how you can create and manage skills using SQL API.

• Creating, inserting into, updating, and deleting a knowledge base:

  CREATE KNOWLEDGE BASE my_knowledge_base
  USING
      model = embedding_model_name,              -- this parameter is optional; if not provided, a suitable embedding model is chosen for the task
      storage = vector_database.storage_table;   -- this parameter is optional; if not provided, the default ChromaDB is used for storage
  
  -- inserts new data rows and generates id for each row if id is not provided
  INSERT INTO my_knowledge_base
      SELECT text AS content FROM datasource.data_table;
  
  -- inserts new data rows and updates existing ones if id value matches
  INSERT INTO my_knowledge_base
      SELECT id, text AS content FROM datasource.data_table;
  
  -- view content of a knowledge base (for example, to look up the generated id values)
  SELECT * FROM my_knowledge_base;
  
  DROP KNOWLEDGE BASE my_knowledge_base;
  

• Creating, updating, and deleting a knowledge_base skill:

  CREATE SKILL kb_skill
  USING
      type = 'knowledge_base',
      source = 'my_knowledge_base', -- this must be created with CREATE KNOWLEDGE BASE
      description = 'My data'; -- data description to help the agent know when to use the knowledge base
  
  UPDATE SKILL kb_skill
  SET
     source = 'new_knowledge_base'; -- this must be created with CREATE KNOWLEDGE BASE
  
  DROP SKILL kb_skill;
  

• Creating, updating, and deleting a text2sql skill:

  CREATE SKILL text_to_sql_skill
  USING
      type = 'text2sql',
      database = 'example_db', -- this must be created with CREATE DATABASE
      tables = ['sales_data'], -- this is a list of tables passed to this skill
      description = "this is sales data";
  
  UPDATE SKILL text_to_sql_skill
  SET
      database = 'new_example_db', -- this must be created with CREATE DATABASE
      tables = ['sales_data'];     -- this is a list of tables passed to this skill
  
  DROP SKILL text_to_sql_skill;
  

You can query all skills using this command:

SHOW KNOWLEDGE_BASES;

SHOW SKILLS;

​

Create an agent

An agent can be created, deleted, queried, and updated. Here is how you can do that using SQL API.

• Creating an AI agent:

  CREATE AGENT my_agent
  USING
     model = 'chatbot_agent', -- this must be a conversational model created with CREATE MODEL (as in the Example section)
     skills = ['test_skill']; -- this must be created with CREATE SKILL
  

  Alternatively, you can create an agent and define the model to be used by an agent at the agent creation time based on the model providers defined here.

  CREATE AGENT my_agent
  USING 
      skills=['text_to_sql_skill'], -- this must be created with CREATE SKILL
      provider='openai', -- choose one of the available model providers (openai, anthropic, anyscale, ollama, litellm, mindsdb)
      model='gpt-4', -- define the model from the provider
      prompt_template='Answer the user input in a helpful way using tools', -- provide instruction to the model
      verbose=True,
      max_tokens=100;
  

• Updating an AI agent:

  UPDATE AGENT my_agent
  SET
     model = 'new_chatbot_agent',           -- this must be a conversational model created with CREATE MODEL
     skills_to_remove = ['test_skill'],
     skills_to_add = ['production_skill'];  -- this must be created with CREATE SKILL
  

• Querying an AI agent:

  SELECT *
  FROM my_agent
  WHERE question = "insert your question"; -- this is the user_column parameter as defined when creating a conversational model for the agent (as in the Example section)
  

• Deleting an AI agent:

  DROP AGENT my_agent;
  

You can query all agents using this command:

SHOW AGENTS [FROM project_name];

SELECT * FROM agents;

​

Example

​

Agents with Text-to-SQL Skills

Start by creating a conversational large language model to be used by an agent.

CREATE MODEL my_model
PREDICT answer
USING
    engine = 'langchain',
    openai_api_key = 'your-model-api-key',
    model_name='gpt-4',
    mode = 'conversational',
    user_column = 'question' ,
    assistant_column = 'answer',
    max_tokens=100,
    temperature=0,
    verbose=True,
    prompt_template='Answer the user input in a helpful way';

Then, connect a data source to be used for creating a skill.

CREATE DATABASE example_db
WITH ENGINE = "postgres",
PARAMETERS = {
    "user": "demo_user",
    "password": "demo_password",
    "host": "samples.mindsdb.com",
    "port": "5432",
    "database": "demo"
    };
 
SELECT * FROM example_db.sales_data;

Create a skill using one or more tables from a connected data source.

CREATE SKILL text_to_sql_skill
USING
    type = 'text2sql',
    database = 'example_db',
    tables = ['car_sales'],
    description = "this is car sales data";

Now that we have a model and a skill, let’s create an agent.

CREATE AGENT text_to_sql_agent
USING
    model = 'my_model',
    skills = ['text_to_sql_skill'];

Query the agent as below:

SELECT *
FROM text_to_sql_agent
WHERE question = "how many cars were sold in 2017?"; -- this column is defined in the user_column parameter in CREATE MODEL

The next step would be to connect a chat app, like Slack, to MindsDB and create a chatbot utilizing this agent.

​

Agents with Knowledge Bases as Skills

In this example, let’s create an embedding model (using OpenAI or LangChain as an engine) for the knowledge base. Note that this step is optional, as knowledge bases provide default embedding model.

CREATE ML_ENGINE openai_engine
FROM openai
USING
   openai_api_key = 'your-openai-api-key';

CREATE MODEL embedding_model
PREDICT embeddings
USING
   engine = 'openai_engine',
   mode='embedding',
   model_name='text-embedding-ada-002',
   question_column = 'content';

Now let’s create a knowledge base that uses this embedding model and the default storage vector database (that is, ChromaDB).

CREATE KNOWLEDGE BASE my_knowledge_base
USING
   model = embedding_model; -- this is optional

This is how you can insert data into the knowledge base and select it.

INSERT INTO my_knowledge_base (content)
VALUES ('I drink tea.');

SELECT * FROM my_knowledge_base;

Use this knowledge base to create a skill for an agent:

CREATE SKILL kb_skill
USING
    type = 'knowledge_base',
    source = 'my_knowledge_base',  -- this must be created with CREATE KNOWLEDGE BASE
    description = 'My data';       -- data description to help the agent know when to use the knowledge base

Now you can assign this skill to the agent ( that was created in the example above) and query it again:

UPDATE AGENT text_to_sql_agent
SET
    skills_to_add = ['kb_skill'];

SELECT *
FROM text_to_sql_agent
WHERE questions = "what is your data?";