vanna 0.5.4__py3-none-any.whl → 0.6.0__py3-none-any.whl

vanna/mock/__init__.py

@@ -0,0 +1,3 @@
+from .embedding import MockEmbedding
+from .llm import MockLLM
+from .vectordb import MockVectorDB

vanna/mock/embedding.py

@@ -0,0 +1,11 @@
+from typing import List
+
+from ..base import VannaBase
+
+
+class MockEmbedding(VannaBase):
+    def __init__(self, config=None):
+        pass
+
+    def generate_embedding(self, data: str, **kwargs) -> List[float]:
+        return [1.0, 2.0, 3.0, 4.0, 5.0]

vanna/mock/llm.py

@@ -0,0 +1,19 @@
+
+from ..base import VannaBase
+
+
+class MockLLM(VannaBase):
+    def __init__(self, config=None):
+        pass
+
+    def system_message(self, message: str) -> any:
+        return {"role": "system", "content": message}
+
+    def user_message(self, message: str) -> any:
+        return {"role": "user", "content": message}
+
+    def assistant_message(self, message: str) -> any:
+        return {"role": "assistant", "content": message}
+
+    def submit_prompt(self, prompt, **kwargs) -> str:
+        return "Mock LLM response"

vanna/mock/vectordb.py

@@ -0,0 +1,55 @@
+import pandas as pd
+
+from ..base import VannaBase
+
+
+class MockVectorDB(VannaBase):
+    def __init__(self, config=None):
+        pass
+
+    def _get_id(self, value: str, **kwargs) -> str:
+        # Hash the value and return the ID
+        return str(hash(value))
+
+    def add_ddl(self, ddl: str, **kwargs) -> str:
+        return self._get_id(ddl)
+
+    def add_documentation(self, doc: str, **kwargs) -> str:
+        return self._get_id(doc)
+
+    def add_question_sql(self, question: str, sql: str, **kwargs) -> str:
+        return self._get_id(question)
+
+    def get_related_ddl(self, question: str, **kwargs) -> list:
+        return []
+
+    def get_related_documentation(self, question: str, **kwargs) -> list:
+        return []
+
+    def get_similar_question_sql(self, question: str, **kwargs) -> list:
+        return []
+
+    def get_training_data(self, **kwargs) -> pd.DataFrame:
+        return pd.DataFrame({'id': {0: '19546-ddl',
+  1: '91597-sql',
+  2: '133976-sql',
+  3: '59851-doc',
+  4: '73046-sql'},
+ 'training_data_type': {0: 'ddl',
+  1: 'sql',
+  2: 'sql',
+  3: 'documentation',
+  4: 'sql'},
+ 'question': {0: None,
+  1: 'What are the top selling genres?',
+  2: 'What are the low 7 artists by sales?',
+  3: None,
+  4: 'What is the total sales for each customer?'},
+ 'content': {0: 'CREATE TABLE [Invoice]\n(\n    [InvoiceId] INTEGER  NOT NULL,\n    [CustomerId] INTEGER  NOT NULL,\n    [InvoiceDate] DATETIME  NOT NULL,\n    [BillingAddress] NVARCHAR(70),\n    [BillingCity] NVARCHAR(40),\n    [BillingState] NVARCHAR(40),\n    [BillingCountry] NVARCHAR(40),\n    [BillingPostalCode] NVARCHAR(10),\n    [Total] NUMERIC(10,2)  NOT NULL,\n    CONSTRAINT [PK_Invoice] PRIMARY KEY  ([InvoiceId]),\n    FOREIGN KEY ([CustomerId]) REFERENCES [Customer] ([CustomerId]) \n\t\tON DELETE NO ACTION ON UPDATE NO ACTION\n)',
+  1: 'SELECT g.Name AS Genre, SUM(il.Quantity) AS TotalSales\nFROM Genre g\nJOIN Track t ON g.GenreId = t.GenreId\nJOIN InvoiceLine il ON t.TrackId = il.TrackId\nGROUP BY g.GenreId, g.Name\nORDER BY TotalSales DESC;',
+  2: 'SELECT a.ArtistId, a.Name, SUM(il.Quantity) AS TotalSales\nFROM Artist a\nINNER JOIN Album al ON a.ArtistId = al.ArtistId\nINNER JOIN Track t ON al.AlbumId = t.AlbumId\nINNER JOIN InvoiceLine il ON t.TrackId = il.TrackId\nGROUP BY a.ArtistId, a.Name\nORDER BY TotalSales ASC\nLIMIT 7;',
+  3: 'This is a SQLite database. For dates rememeber to use SQLite syntax.',
+  4: 'SELECT c.CustomerId, c.FirstName, c.LastName, SUM(i.Total) AS TotalSales\nFROM Customer c\nJOIN Invoice i ON c.CustomerId = i.CustomerId\nGROUP BY c.CustomerId, c.FirstName, c.LastName;'}})
+
+    def remove_training_data(id: str, **kwargs) -> bool:
+        return True

vanna/opensearch/opensearch_vector.py

@@ -155,6 +155,11 @@ class OpenSearch_VectorStore(VannaBase):
     else:
       max_retries = 10
 
+    if config is not None and "es_http_compress" in config:
+      es_http_compress = config["es_http_compress"]
+    else:
+      es_http_compress = False
+
     print("OpenSearch_VectorStore initialized with es_urls: ", es_urls,
           " host: ", host, " port: ", port, " ssl: ", ssl, " verify_certs: ",
           verify_certs, " timeout: ", timeout, " max_retries: ", max_retries)
@@ -162,7 +167,7 @@ class OpenSearch_VectorStore(VannaBase):
       # Initialize the OpenSearch client by passing a list of URLs
       self.client = OpenSearch(
         hosts=[es_urls],
-        http_compress=True,
+        http_compress=es_http_compress,
         use_ssl=ssl,
         verify_certs=verify_certs,
         timeout=timeout,
@@ -175,7 +180,7 @@ class OpenSearch_VectorStore(VannaBase):
       # Initialize the OpenSearch client by passing a host and port
       self.client = OpenSearch(
         hosts=[{'host': host, 'port': port}],
-        http_compress=True,
+        http_compress=es_http_compress,
         use_ssl=ssl,
         verify_certs=verify_certs,
         timeout=timeout,
@@ -267,6 +272,7 @@ class OpenSearch_VectorStore(VannaBase):
         }
       }
     }
+    print(query)
     response = self.client.search(index=self.ddl_index, body=query,
                                   **kwargs)
     return [hit['_source']['ddl'] for hit in response['hits']['hits']]
@@ -279,6 +285,7 @@ class OpenSearch_VectorStore(VannaBase):
         }
       }
     }
+    print(query)
     response = self.client.search(index=self.document_index,
                                   body=query,
                                   **kwargs)
@@ -292,6 +299,7 @@ class OpenSearch_VectorStore(VannaBase):
         }
       }
     }
+    print(query)
     response = self.client.search(index=self.question_sql_index,
                                   body=query,
                                   **kwargs)
@@ -307,6 +315,7 @@ class OpenSearch_VectorStore(VannaBase):
       body={"query": {"match_all": {}}},
       size=1000
     )
+    print(query)
     # records = [hit['_source'] for hit in response['hits']['hits']]
     for hit in response['hits']['hits']:
       data.append(

vanna/pinecone/__init__.py

@@ -0,0 +1,3 @@
+from .pinecone_vector import PineconeDB_VectorStore
+
+__all__ = ["PineconeDB_VectorStore"]

vanna/pinecone/pinecone_vector.py

@@ -0,0 +1,275 @@
+import json
+from typing import List
+
+from pinecone import Pinecone, PodSpec, ServerlessSpec
+import pandas as pd
+from ..base import VannaBase
+from ..utils import deterministic_uuid
+
+from fastembed import TextEmbedding
+
+
+class PineconeDB_VectorStore(VannaBase):
+    """
+    Vectorstore using PineconeDB
+
+    Args:
+        config (dict): Configuration dictionary. Defaults to {}. You must provide either a Pinecone Client or an API key in the config.
+            - client (Pinecone, optional): Pinecone client. Defaults to None.
+            - api_key (str, optional): Pinecone API key. Defaults to None.
+            - n_results (int, optional): Number of results to return. Defaults to 10.
+            - dimensions (int, optional): Dimensions of the embeddings. Defaults to 384 which coresponds to the dimensions of BAAI/bge-small-en-v1.5.
+            - fastembed_model (str, optional): Fastembed model to use. Defaults to "BAAI/bge-small-en-v1.5".
+            - documentation_namespace (str, optional): Namespace for documentation. Defaults to "documentation".
+            - distance_metric (str, optional): Distance metric to use. Defaults to "cosine".
+            - ddl_namespace (str, optional): Namespace for DDL. Defaults to "ddl".
+            - sql_namespace (str, optional): Namespace for SQL. Defaults to "sql".
+            - index_name (str, optional): Name of the index. Defaults to "vanna-index".
+            - metadata_config (dict, optional): Metadata configuration if using a pinecone pod. Defaults to {}.
+            - server_type (str, optional): Type of Pinecone server to use. Defaults to "serverless". Options are "serverless" or "pod".
+            - podspec (PodSpec, optional): PodSpec configuration if using a pinecone pod. Defaults to PodSpec(environment="us-west-2", pod_type="p1.x1", metadata_config=self.metadata_config).
+            - serverless_spec (ServerlessSpec, optional): ServerlessSpec configuration if using a pinecone serverless index. Defaults to ServerlessSpec(cloud="aws", region="us-west-2").
+    Raises:
+        ValueError: If config is None, api_key is not provided OR client is not provided, client is not an instance of Pinecone, or server_type is not "serverless" or "pod".
+    """
+
+    def __init__(self, config=None):
+        VannaBase.__init__(self, config=config)
+        if config is None:
+            raise ValueError(
+                "config is required, pass either a Pinecone client or an API key in the config."
+            )
+        client = config.get("client")
+        api_key = config.get("api_key")
+        if not api_key and not client:
+            raise ValueError(
+                "api_key is required in config or pass a configured client"
+            )
+        if not client and api_key:
+            self._client = Pinecone(api_key=api_key)
+        elif not isinstance(client, Pinecone):
+            raise ValueError("client must be an instance of Pinecone")
+        else:
+            self._client = client
+
+        self.n_results = config.get("n_results", 10)
+        self.dimensions = config.get("dimensions", 384)
+        self.fastembed_model = config.get("fastembed_model", "BAAI/bge-small-en-v1.5")
+        self.documentation_namespace = config.get(
+            "documentation_namespace", "documentation"
+        )
+        self.distance_metric = config.get("distance_metric", "cosine")
+        self.ddl_namespace = config.get("ddl_namespace", "ddl")
+        self.sql_namespace = config.get("sql_namespace", "sql")
+        self.index_name = config.get("index_name", "vanna-index")
+        self.metadata_config = config.get("metadata_config", {})
+        self.server_type = config.get("server_type", "serverless")
+        if self.server_type not in ["serverless", "pod"]:
+            raise ValueError("server_type must be either 'serverless' or 'pod'")
+        self.podspec = config.get(
+            "podspec",
+            PodSpec(
+                environment="us-west-2",
+                pod_type="p1.x1",
+                metadata_config=self.metadata_config,
+            ),
+        )
+        self.serverless_spec = config.get(
+            "serverless_spec", ServerlessSpec(cloud="aws", region="us-west-2")
+        )
+        self._setup_index()
+
+    def _set_index_host(self, host: str) -> None:
+        self.Index = self._client.Index(host=host)
+
+    def _setup_index(self) -> None:
+        existing_indexes = self._get_indexes()
+        if self.index_name not in existing_indexes and self.server_type == "serverless":
+            self._client.create_index(
+                name=self.index_name,
+                dimension=self.dimensions,
+                metric=self.distance_metric,
+                spec=self.serverless_spec,
+            )
+            pinecone_index_host = self._client.describe_index(self.index_name)["host"]
+            self._set_index_host(pinecone_index_host)
+        elif self.index_name not in existing_indexes and self.server_type == "pod":
+            self._client.create_index(
+                name=self.index_name,
+                dimension=self.dimensions,
+                metric=self.distance_metric,
+                spec=self.podspec,
+            )
+            pinecone_index_host = self._client.describe_index(self.index_name)["host"]
+            self._set_index_host(pinecone_index_host)
+        else:
+            pinecone_index_host = self._client.describe_index(self.index_name)["host"]
+            self._set_index_host(pinecone_index_host)
+
+    def _get_indexes(self) -> list:
+        return [index["name"] for index in self._client.list_indexes()]
+
+    def _check_if_embedding_exists(self, id: str, namespace: str) -> bool:
+        fetch_response = self.Index.fetch(ids=[id], namespace=namespace)
+        if fetch_response["vectors"] == {}:
+            return False
+        return True
+
+    def add_ddl(self, ddl: str, **kwargs) -> str:
+        id = deterministic_uuid(ddl) + "-ddl"
+        if self._check_if_embedding_exists(id=id, namespace=self.ddl_namespace):
+            print(f"DDL with id: {id} already exists in the index. Skipping...")
+            return id
+        self.Index.upsert(
+            vectors=[(id, self.generate_embedding(ddl), {"ddl": ddl})],
+            namespace=self.ddl_namespace,
+        )
+        return id
+
+    def add_documentation(self, doc: str, **kwargs) -> str:
+        id = deterministic_uuid(doc) + "-doc"
+
+        if self._check_if_embedding_exists(
+            id=id, namespace=self.documentation_namespace
+        ):
+            print(
+                f"Documentation with id: {id} already exists in the index. Skipping..."
+            )
+            return id
+        self.Index.upsert(
+            vectors=[(id, self.generate_embedding(doc), {"documentation": doc})],
+            namespace=self.documentation_namespace,
+        )
+        return id
+
+    def add_question_sql(self, question: str, sql: str, **kwargs) -> str:
+        question_sql_json = json.dumps(
+            {
+                "question": question,
+                "sql": sql,
+            },
+            ensure_ascii=False,
+        )
+        id = deterministic_uuid(question_sql_json) + "-sql"
+        if self._check_if_embedding_exists(id=id, namespace=self.sql_namespace):
+            print(
+                f"Question-SQL with id: {id} already exists in the index. Skipping..."
+            )
+            return id
+        self.Index.upsert(
+            vectors=[
+                (
+                    id,
+                    self.generate_embedding(question_sql_json),
+                    {"sql": question_sql_json},
+                )
+            ],
+            namespace=self.sql_namespace,
+        )
+        return id
+
+    def get_related_ddl(self, question: str, **kwargs) -> list:
+        res = self.Index.query(
+            namespace=self.ddl_namespace,
+            vector=self.generate_embedding(question),
+            top_k=self.n_results,
+            include_values=True,
+            include_metadata=True,
+        )
+        return [match["metadata"]["ddl"] for match in res["matches"]] if res else []
+
+    def get_related_documentation(self, question: str, **kwargs) -> list:
+        res = self.Index.query(
+            namespace=self.documentation_namespace,
+            vector=self.generate_embedding(question),
+            top_k=self.n_results,
+            include_values=True,
+            include_metadata=True,
+        )
+        return (
+            [match["metadata"]["documentation"] for match in res["matches"]]
+            if res
+            else []
+        )
+
+    def get_similar_question_sql(self, question: str, **kwargs) -> list:
+        res = self.Index.query(
+            namespace=self.sql_namespace,
+            vector=self.generate_embedding(question),
+            top_k=self.n_results,
+            include_values=True,
+            include_metadata=True,
+        )
+        return (
+            [
+                {
+                    key: value
+                    for key, value in json.loads(match["metadata"]["sql"]).items()
+                }
+                for match in res["matches"]
+            ]
+            if res
+            else []
+        )
+
+    def get_training_data(self, **kwargs) -> pd.DataFrame:
+        # Pinecone does not support getting all vectors in a namespace, so we have to query for the top_k vectors with a dummy vector
+        df = pd.DataFrame()
+        namespaces = {
+            "sql": self.sql_namespace,
+            "ddl": self.ddl_namespace,
+            "documentation": self.documentation_namespace,
+        }
+
+        for data_type, namespace in namespaces.items():
+            data = self.Index.query(
+                top_k=10000,  # max results that pinecone allows
+                namespace=namespace,
+                include_values=True,
+                include_metadata=True,
+                vector=[0.0] * self.dimensions,
+            )
+
+            if data is not None:
+                id_list = [match["id"] for match in data["matches"]]
+                content_list = [
+                    match["metadata"][data_type] for match in data["matches"]
+                ]
+                question_list = [
+                    (
+                        json.loads(match["metadata"][data_type])["question"]
+                        if data_type == "sql"
+                        else None
+                    )
+                    for match in data["matches"]
+                ]
+
+                df_data = pd.DataFrame(
+                    {
+                        "id": id_list,
+                        "question": question_list,
+                        "content": content_list,
+                    }
+                )
+                df_data["training_data_type"] = data_type
+                df = pd.concat([df, df_data])
+
+        return df
+
+    def remove_training_data(self, id: str, **kwargs) -> bool:
+        if id.endswith("-sql"):
+            self.Index.delete(ids=[id], namespace=self.sql_namespace)
+            return True
+        elif id.endswith("-ddl"):
+            self.Index.delete(ids=[id], namespace=self.ddl_namespace)
+            return True
+        elif id.endswith("-doc"):
+            self.Index.delete(ids=[id], namespace=self.documentation_namespace)
+            return True
+        else:
+            return False
+
+    def generate_embedding(self, data: str, **kwargs) -> List[float]:
+        embedding_model = TextEmbedding(model_name=self.fastembed_model)
+        embedding = next(embedding_model.embed(data))
+        return embedding.tolist()

vanna/qdrant/qdrant.py

@@ -3,6 +3,7 @@ from typing import List, Tuple
 
 import pandas as pd
 from qdrant_client import QdrantClient, grpc, models
+from qdrant_client.http.models.models import UpdateStatus
 
 from ..base import VannaBase
 from ..utils import deterministic_uuid
@@ -210,7 +211,8 @@ class Qdrant_VectorStore(VannaBase):
     def remove_training_data(self, id: str, **kwargs) -> bool:
         try:
             id, collection_name = self._parse_point_id(id)
-            self._client.delete(collection_name, points_selector=[id])
+            res = self._client.delete(collection_name, points_selector=[id])
+            res == UpdateStatus.COMPLETED
         except ValueError:
             return False
 

vanna/vannadb/vannadb_vector.py

@@ -5,6 +5,7 @@ from io import StringIO
 import pandas as pd
 import requests
 
+from ..advanced import VannaAdvanced
 from ..base import VannaBase
 from ..types import (
   DataFrameJSON,
@@ -20,7 +21,7 @@ from ..types import (
 from ..utils import sanitize_model_name
 
 
-class VannaDB_VectorStore(VannaBase):
+class VannaDB_VectorStore(VannaBase, VannaAdvanced):
     def __init__(self, vanna_model: str, vanna_api_key: str, config=None):
         VannaBase.__init__(self, config=config)
 
@@ -33,6 +34,12 @@ class VannaDB_VectorStore(VannaBase):
             else config["endpoint"]
         )
         self.related_training_data = {}
+        self._graphql_endpoint = "https://functionrag.com/query"
+        self._graphql_headers = {
+            "Content-Type": "application/json",
+            "API-KEY": self._api_key,
+            "NAMESPACE": self._model,
+        }
 
     def _rpc_call(self, method, params):
         if method != "list_orgs":
@@ -59,6 +66,177 @@ class VannaDB_VectorStore(VannaBase):
     def _dataclass_to_dict(self, obj):
         return dataclasses.asdict(obj)
 
+    def get_all_functions(self) -> list:
+        query = """
+            {
+                get_all_sql_functions {
+                    function_name
+                    description
+                    post_processing_code_template
+                    arguments {
+                        name
+                        description
+                        general_type
+                        is_user_editable
+                        available_values
+                    }
+                    sql_template
+                }
+            }
+        """
+
+        response = requests.post(self._graphql_endpoint, headers=self._graphql_headers, json={'query': query})
+        response_json = response.json()
+        if response.status_code == 200 and 'data' in response_json and 'get_all_sql_functions' in response_json['data']:
+            self.log(response_json['data']['get_all_sql_functions'])
+            resp = response_json['data']['get_all_sql_functions']
+
+            print(resp)
+
+            return resp
+        else:
+            raise Exception(f"Query failed to run by returning code of {response.status_code}. {response.text}")
+
+
+    def get_function(self, question: str, additional_data: dict = {}) -> dict:
+        query = """
+        query GetFunction($question: String!, $staticFunctionArguments: [StaticFunctionArgument]) {
+            get_and_instantiate_function(question: $question, static_function_arguments: $staticFunctionArguments) {
+                ... on SQLFunction {
+                function_name
+                description
+                post_processing_code_template
+                instantiated_post_processing_code
+                arguments {
+                    name
+                    description
+                    general_type
+                    is_user_editable
+                    instantiated_value
+                    available_values
+                }
+                sql_template
+                instantiated_sql
+            }
+            }
+        }
+        """
+        static_function_arguments = [{"name": key, "value": str(value)} for key, value in additional_data.items()]
+        variables = {"question": question, "staticFunctionArguments": static_function_arguments}
+        response = requests.post(self._graphql_endpoint, headers=self._graphql_headers, json={'query': query, 'variables': variables})
+        response_json = response.json()
+        if response.status_code == 200 and 'data' in response_json and 'get_and_instantiate_function' in response_json['data']:
+            self.log(response_json['data']['get_and_instantiate_function'])
+            resp = response_json['data']['get_and_instantiate_function']
+
+            print(resp)
+
+            return resp
+        else:
+            raise Exception(f"Query failed to run by returning code of {response.status_code}. {response.text}")
+
+    def create_function(self, question: str, sql: str, plotly_code: str, **kwargs) -> dict:
+        query = """
+        mutation CreateFunction($question: String!, $sql: String!, $plotly_code: String!) {
+            generate_and_create_sql_function(question: $question, sql: $sql, post_processing_code: $plotly_code) {
+                function_name
+                description
+                arguments {
+                    name
+                    description
+                    general_type
+                    is_user_editable
+                }
+                sql_template
+                post_processing_code_template
+            }
+        }
+        """
+        variables = {"question": question, "sql": sql, "plotly_code": plotly_code}
+        response = requests.post(self._graphql_endpoint, headers=self._graphql_headers, json={'query': query, 'variables': variables})
+        response_json = response.json()
+        if response.status_code == 200 and 'data' in response_json and response_json['data'] is not None and 'generate_and_create_sql_function' in response_json['data']:
+            resp = response_json['data']['generate_and_create_sql_function']
+
+            print(resp)
+
+            return resp
+        else:
+            raise Exception(f"Query failed to run by returning code of {response.status_code}. {response.text}")
+
+    def update_function(self, old_function_name: str, updated_function: dict) -> bool:
+        """
+        Update an existing SQL function based on the provided parameters.
+
+        Args:
+            old_function_name (str): The current name of the function to be updated.
+            updated_function (dict): A dictionary containing the updated function details. Expected keys:
+                - 'function_name': The new name of the function.
+                - 'description': The new description of the function.
+                - 'arguments': A list of dictionaries describing the function arguments.
+                - 'sql_template': The new SQL template for the function.
+                - 'post_processing_code_template': The new post-processing code template.
+
+        Returns:
+            bool: True if the function was successfully updated, False otherwise.
+        """
+        mutation = """
+        mutation UpdateSQLFunction($input: SQLFunctionUpdate!) {
+            update_sql_function(input: $input)
+        }
+        """
+
+        SQLFunctionUpdate = {
+            'function_name', 'description', 'arguments', 'sql_template', 'post_processing_code_template'
+        }
+
+        # Define the expected keys for each argument in the arguments list
+        ArgumentKeys = {'name', 'general_type', 'description', 'is_user_editable', 'available_values'}
+
+        # Function to validate and transform arguments
+        def validate_arguments(args):
+            return [
+                {key: arg[key] for key in arg if key in ArgumentKeys}
+                for arg in args
+            ]
+
+        # Keep only the keys that conform to the SQLFunctionUpdate GraphQL input type
+        updated_function = {key: value for key, value in updated_function.items() if key in SQLFunctionUpdate}
+
+        # Special handling for 'arguments' to ensure they conform to the spec
+        if 'arguments' in updated_function:
+            updated_function['arguments'] = validate_arguments(updated_function['arguments'])
+
+        variables = {
+            "input": {
+                "old_function_name": old_function_name,
+                **updated_function
+            }
+        }
+
+        print("variables", variables)
+
+        response = requests.post(self._graphql_endpoint, headers=self._graphql_headers, json={'query': mutation, 'variables': variables})
+        response_json = response.json()
+        if response.status_code == 200 and 'data' in response_json and response_json['data'] is not None and 'update_sql_function' in response_json['data']:
+            return response_json['data']['update_sql_function']
+        else:
+            raise Exception(f"Mutation failed to run by returning code of {response.status_code}. {response.text}")
+
+    def delete_function(self, function_name: str) -> bool:
+        mutation = """
+        mutation DeleteSQLFunction($function_name: String!) {
+            delete_sql_function(function_name: $function_name)
+        }
+        """
+        variables = {"function_name": function_name}
+        response = requests.post(self._graphql_endpoint, headers=self._graphql_headers, json={'query': mutation, 'variables': variables})
+        response_json = response.json()
+        if response.status_code == 200 and 'data' in response_json and response_json['data'] is not None and 'delete_sql_function' in response_json['data']:
+            return response_json['data']['delete_sql_function']
+        else:
+            raise Exception(f"Mutation failed to run by returning code of {response.status_code}. {response.text}")
+
     def create_model(self, model: str, **kwargs) -> bool:
         """
         **Example:**