vanna 0.7.5__py3-none-any.whl → 0.7.6__py3-none-any.whl

vanna/base/base.py

@@ -306,7 +306,7 @@ class VannaBase(ABC):
 
         message_log = [
             self.system_message(
-                f"You are a helpful data assistant. The user asked the question: '{question}'\n\nThe SQL query for this question was: {sql}\n\nThe following is a pandas DataFrame with the results of the query: \n{df.to_markdown()}\n\n"
+                f"You are a helpful data assistant. The user asked the question: '{question}'\n\nThe SQL query for this question was: {sql}\n\nThe following is a pandas DataFrame with the results of the query: \n{df.head(25).to_markdown()}\n\n"
             ),
             self.user_message(
                 f"Generate a list of {n_questions} followup questions that the user might ask about this data. Respond with a list of questions, one per line. Do not answer with any explanations -- just the questions. Remember that there should be an unambiguous SQL query that can be generated from the question. Prefer questions that are answerable outside of the context of this conversation. Prefer questions that are slight modifications of the SQL query that was generated that allow digging deeper into the data. Each question will be turned into a button that the user can click to generate a new SQL query so don't use 'example' type questions. Each question must have a one-to-one correspondence with an instantiated SQL query." +
@@ -689,6 +689,9 @@ class VannaBase(ABC):
         return response
 
     def _extract_python_code(self, markdown_string: str) -> str:
+        # Strip whitespace to avoid indentation errors in LLM-generated code
+        markdown_string = markdown_string.strip()
+
         # Regex pattern to match Python code blocks
         pattern = r"```[\w\s]*python\n([\s\S]*?)```|```([\s\S]*?)```"
 
@@ -1167,7 +1170,7 @@ class VannaBase(ABC):
         vn.connect_to_oracle(
         user="username",
         password="password",
-        dns="host:port/sid",
+        dsn="host:port/sid",
         )
         ```
         Args:

vanna/deepseek/__init__.py

@@ -0,0 +1 @@
+from .deepseek_chat import DeepSeekChat

vanna/deepseek/deepseek_chat.py

@@ -0,0 +1,60 @@
+import os
+
+from openai import OpenAI
+
+from ..base import VannaBase
+
+
+
+# from vanna.chromadb import ChromaDB_VectorStore
+
+# class DeepSeekVanna(ChromaDB_VectorStore, DeepSeekChat):
+#     def __init__(self, config=None):
+#         ChromaDB_VectorStore.__init__(self, config=config)
+#         DeepSeekChat.__init__(self, config=config)
+
+# vn = DeepSeekVanna(config={"api_key": "sk-************", "model": "deepseek-chat"})
+
+
+class DeepSeekChat(VannaBase):
+    def __init__(self, config=None):
+        if config is None:
+            raise ValueError(
+                "For DeepSeek, config must be provided with an api_key and model"
+            )
+        if "api_key" not in config:
+            raise ValueError("config must contain a DeepSeek api_key")
+
+        if "model" not in config:
+            raise ValueError("config must contain a DeepSeek model")
+    
+        api_key = config["api_key"]
+        model = config["model"]
+        self.model = model
+        self.client = OpenAI(api_key=api_key, base_url="https://api.deepseek.com/v1")
+        
+    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 generate_sql(self, question: str, **kwargs) -> str:
+        # 使用父类的 generate_sql
+        sql = super().generate_sql(question, **kwargs)
+        
+        # 替换 "\_" 为 "_"
+        sql = sql.replace("\\_", "_")
+        
+        return sql
+
+    def submit_prompt(self, prompt, **kwargs) -> str:
+        chat_response = self.client.chat.completions.create(
+            model=self.model,
+            messages=prompt,
+        )
+        
+        return chat_response.choices[0].message.content

vanna/google/gemini_chat.py

@@ -1,4 +1,5 @@
 import os
+
 from ..base import VannaBase
 
 
@@ -30,8 +31,29 @@ class GoogleGeminiChat(VannaBase):
             self.chat_model = genai.GenerativeModel(model_name)
         else:
             # Authenticate using VertexAI
+            import google.auth
+            import vertexai
             from vertexai.generative_models import GenerativeModel
-            self.chat_model = GenerativeModel(model_name)
+
+            json_file_path = config.get("google_credentials")  # Assuming the JSON file path is provided in the config
+
+            if not json_file_path or not os.path.exists(json_file_path):
+                raise FileNotFoundError(f"JSON credentials file not found at: {json_file_path}")
+
+            try:
+                # Validate and set the JSON file path for GOOGLE_APPLICATION_CREDENTIALS
+                os.environ['GOOGLE_APPLICATION_CREDENTIALS'] = json_file_path
+
+                # Initialize VertexAI with the credentials
+                credentials, _ = google.auth.default()
+                vertexai.init(credentials=credentials)
+                self.chat_model = GenerativeModel(model_name)
+            except google.auth.exceptions.DefaultCredentialsError as e:
+                raise RuntimeError(f"Default credentials error: {e}")
+            except google.auth.exceptions.TransportError as e:
+                raise RuntimeError(f"Transport error during authentication: {e}")
+            except Exception as e:
+                raise RuntimeError(f"Failed to authenticate using JSON file: {e}")
 
     def system_message(self, message: str) -> any:
         return message

vanna/ollama/ollama.py

@@ -91,7 +91,7 @@ class Ollama(VannaBase):
       f"model={self.model},\n"
       f"options={self.ollama_options},\n"
       f"keep_alive={self.keep_alive}")
-    self.log(f"Prompt Content:\n{json.dumps(prompt)}")
+    self.log(f"Prompt Content:\n{json.dumps(prompt, ensure_ascii=False)}")
     response_dict = self.ollama_client.chat(model=self.model,
                                             messages=prompt,
                                             stream=False,

vanna/opensearch/__init__.py

@@ -1 +1,2 @@
 from .opensearch_vector import OpenSearch_VectorStore
+from .opensearch_vector_semantic import OpenSearch_Semantic_VectorStore

vanna/opensearch/opensearch_vector_semantic.py

@@ -0,0 +1,175 @@
+import json
+
+import pandas as pd
+from langchain_community.vectorstores import OpenSearchVectorSearch
+
+from ..base import VannaBase
+from ..utils import deterministic_uuid
+
+
+class OpenSearch_Semantic_VectorStore(VannaBase):
+  def __init__(self, config=None):
+    VannaBase.__init__(self, config=config)
+    if config is None:
+      config = {}
+
+    if "embedding_function" in config:
+      self.embedding_function = config.get("embedding_function")
+    else:
+      from langchain_huggingface import HuggingFaceEmbeddings
+      self.embedding_function = HuggingFaceEmbeddings(model_name="all-MiniLM-L6-v2")
+
+    self.n_results_sql = config.get("n_results_sql", config.get("n_results", 10))
+    self.n_results_documentation = config.get("n_results_documentation", config.get("n_results", 10))
+    self.n_results_ddl = config.get("n_results_ddl", config.get("n_results", 10))
+
+    self.document_index = config.get("es_document_index", "vanna_document_index")
+    self.ddl_index = config.get("es_ddl_index", "vanna_ddl_index")
+    self.question_sql_index = config.get("es_question_sql_index", "vanna_questions_sql_index")
+
+    self.log(f"OpenSearch_Semantic_VectorStore initialized with document_index: {self.document_index}, ddl_index: {self.ddl_index}, question_sql_index: {self.question_sql_index}")
+
+    es_urls = config.get("es_urls", "https://localhost:9200")
+    ssl = config.get("es_ssl", True)
+    verify_certs = config.get("es_verify_certs", True)
+
+    if "es_user" in config:
+      auth = (config["es_user"], config["es_password"])
+    else:
+      auth = None
+
+    headers = config.get("es_headers", None)
+    timeout = config.get("es_timeout", 60)
+    max_retries = config.get("es_max_retries", 10)
+
+    common_args = {
+        "opensearch_url": es_urls,
+        "embedding_function": self.embedding_function,
+        "engine": "faiss",
+        "http_auth": auth,
+        "use_ssl": ssl,
+        "verify_certs": verify_certs,
+        "timeout": timeout,
+        "max_retries": max_retries,
+        "retry_on_timeout": True,
+        "headers": headers,
+    }
+
+    self.documentation_store = OpenSearchVectorSearch(index_name=self.document_index, **common_args)
+    self.ddl_store = OpenSearchVectorSearch(index_name=self.ddl_index, **common_args)
+    self.sql_store = OpenSearchVectorSearch(index_name=self.question_sql_index, **common_args)
+
+  def add_ddl(self, ddl: str, **kwargs) -> str:
+    _id = deterministic_uuid(ddl) + "-ddl"
+    self.ddl_store.add_texts(texts=[ddl], ids=[_id], **kwargs)
+    return _id
+
+  def add_documentation(self, documentation: str, **kwargs) -> str:
+    _id = deterministic_uuid(documentation) + "-doc"
+    self.documentation_store.add_texts(texts=[documentation], ids=[_id], **kwargs)
+    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"
+    self.sql_store.add_texts(texts=[question_sql_json], ids=[_id], **kwargs)
+    return _id
+
+  def get_related_ddl(self, question: str, **kwargs) -> list:
+    documents = self.ddl_store.similarity_search(query=question, k=self.n_results_ddl)
+    return [document.page_content for document in documents]
+
+  def get_related_documentation(self, question: str, **kwargs) -> list:
+    documents = self.documentation_store.similarity_search(query=question, k=self.n_results_documentation)
+    return [document.page_content for document in documents]
+
+  def get_similar_question_sql(self, question: str, **kwargs) -> list:
+    documents = self.sql_store.similarity_search(query=question, k=self.n_results_sql)
+    return [json.loads(document.page_content) for document in documents]
+
+  def get_training_data(self, **kwargs) -> pd.DataFrame:
+    data = []
+    query = {
+      "query": {
+        "match_all": {}
+      }
+    }
+
+    indices = [
+      {"index": self.document_index, "type": "documentation"},
+      {"index": self.question_sql_index, "type": "sql"},
+      {"index": self.ddl_index, "type": "ddl"},
+    ]
+
+    # Use documentation_store.client consistently for search on all indices
+    opensearch_client = self.documentation_store.client
+
+    for index_info in indices:
+      index_name = index_info["index"]
+      training_data_type = index_info["type"]
+      scroll = '1m'  # keep scroll context for 1 minute
+      response = opensearch_client.search(
+        index=index_name,
+        ignore_unavailable=True,
+        body=query,
+        scroll=scroll,
+        size=1000
+      )
+
+      scroll_id = response.get('_scroll_id')
+
+      while scroll_id:
+        hits = response['hits']['hits']
+        if not hits:
+          break  # No more hits, exit loop
+
+        for hit in hits:
+          source = hit['_source']
+          if training_data_type == "sql":
+            try:
+              doc_dict = json.loads(source['text'])
+              content = doc_dict.get("sql")
+              question = doc_dict.get("question")
+            except json.JSONDecodeError as e:
+              self.log(f"Skipping row with custom_id {hit['_id']} due to JSON parsing error: {e}","Error")
+              continue
+          else:  # documentation or ddl
+            content = source['text']
+            question = None
+
+          data.append({
+            "id": hit["_id"],
+            "training_data_type": training_data_type,
+            "question": question,
+            "content": content,
+          })
+
+        # Get next batch of results, using documentation_store.client.scroll
+        response = opensearch_client.scroll(scroll_id=scroll_id, scroll=scroll)
+        scroll_id = response.get('_scroll_id')
+
+    return pd.DataFrame(data)
+
+  def remove_training_data(self, id: str, **kwargs) -> bool:
+    try:
+      if id.endswith("-sql"):
+        return self.sql_store.delete(ids=[id], **kwargs)
+      elif id.endswith("-ddl"):
+        return self.ddl_store.delete(ids=[id], **kwargs)
+      elif id.endswith("-doc"):
+        return self.documentation_store.delete(ids=[id], **kwargs)
+      else:
+        return False
+    except Exception as e:
+      self.log(f"Error deleting training dataError deleting training data: {e}", "Error")
+      return False
+
+  def generate_embedding(self, data: str, **kwargs) -> list[float]:
+    pass

vanna/oracle/__init__.py

@@ -0,0 +1 @@
+from .oracle_vector import Oracle_VectorStore

vanna/oracle/oracle_vector.py

@@ -0,0 +1,585 @@
+import json
+import uuid
+from typing import List, Optional, Tuple
+
+import oracledb
+import pandas as pd
+from chromadb.utils import embedding_functions
+
+from ..base import VannaBase
+
+default_ef = embedding_functions.DefaultEmbeddingFunction()
+
+
+class Oracle_VectorStore(VannaBase):
+  def __init__(self, config=None):
+    VannaBase.__init__(self, config=config)
+
+    if config is not None:
+      self.embedding_function = config.get(
+        "embedding_function",
+        default_ef
+      )
+      self.pre_delete_collection = config.get("pre_delete_collection",
+                                              False)
+      self.cmetadata = config.get("cmetadata", {"created_by": "oracle"})
+    else:
+      self.embedding_function = default_ef
+      self.pre_delete_collection = False
+      self.cmetadata = {"created_by": "oracle"}
+
+    self.oracle_conn = oracledb.connect(dsn=config.get("dsn"))
+    self.oracle_conn.call_timeout = 30000
+    self.documentation_collection = "documentation"
+    self.ddl_collection = "ddl"
+    self.sql_collection = "sql"
+    self.n_results = config.get("n_results", 10)
+    self.n_results_ddl = config.get("n_results_ddl", self.n_results)
+    self.n_results_sql = config.get("n_results_sql", self.n_results)
+    self.n_results_documentation = config.get("n_results_documentation",
+                                              self.n_results)
+    self.create_tables_if_not_exists()
+    self.create_collections_if_not_exists(self.documentation_collection)
+    self.create_collections_if_not_exists(self.ddl_collection)
+    self.create_collections_if_not_exists(self.sql_collection)
+
+  def generate_embedding(self, data: str, **kwargs) -> List[float]:
+    embeddings = self.embedding_function([data])
+    if len(embeddings) == 1:
+      return list(embeddings[0].astype(float))
+    return list(embeddings.astype(float))
+
+  def add_question_sql(self, question: str, sql: str, **kwargs) -> str:
+    cmetadata = self.cmetadata.copy()
+    collection = self.get_collection(self.sql_collection)
+    question_sql_json = json.dumps(
+      {
+        "question": question,
+        "sql": sql,
+      },
+      ensure_ascii=False,
+    )
+    id = str(uuid.uuid4())
+    embeddings = self.generate_embedding(question)
+    custom_id = id + "-sql"
+
+    cursor = self.oracle_conn.cursor()
+    cursor.setinputsizes(None, oracledb.DB_TYPE_VECTOR)
+    cursor.execute(
+      """
+          INSERT INTO oracle_embedding (
+              collection_id,
+              embedding,
+              document,
+              cmetadata,
+              custom_id,
+              uuid
+          ) VALUES (
+              :1,
+              TO_VECTOR(:2),
+              :3,
+              :4,
+              :5,
+              :6
+          )
+      """, [
+        collection["uuid"],
+        embeddings,
+        question_sql_json,
+        json.dumps(cmetadata),
+        custom_id,
+        id
+      ]
+    )
+
+    self.oracle_conn.commit()
+    cursor.close()
+    return id
+
+  def add_ddl(self, ddl: str, **kwargs) -> str:
+    collection = self.get_collection(self.ddl_collection)
+    question_ddl_json = json.dumps(
+      {
+        "question": None,
+        "ddl": ddl,
+      },
+      ensure_ascii=False,
+    )
+    id = str(uuid.uuid4())
+    custom_id = id + "-ddl"
+    cursor = self.oracle_conn.cursor()
+    cursor.setinputsizes(None, oracledb.DB_TYPE_VECTOR)
+    cursor.execute(
+      """
+      INSERT INTO oracle_embedding (
+          collection_id,
+          embedding,
+          document,
+          cmetadata,
+          custom_id,
+          uuid
+      ) VALUES (
+          :1,
+          TO_VECTOR(:2),
+          :3,
+          :4,
+          :5,
+          :6
+      )
+      """, [
+        collection["uuid"],
+        self.generate_embedding(ddl),
+        question_ddl_json,
+        json.dumps(self.cmetadata),
+        custom_id,
+        id
+      ]
+    )
+    self.oracle_conn.commit()
+    cursor.close()
+    return id
+
+  def add_documentation(self, documentation: str, **kwargs) -> str:
+    collection = self.get_collection(self.documentation_collection)
+    question_documentation_json = json.dumps(
+      {
+        "question": None,
+        "documentation": documentation,
+      },
+      ensure_ascii=False,
+    )
+    id = str(uuid.uuid4())
+    custom_id = id + "-doc"
+    cursor = self.oracle_conn.cursor()
+    cursor.setinputsizes(None, oracledb.DB_TYPE_VECTOR)
+    cursor.execute(
+      """
+      INSERT INTO oracle_embedding (
+          collection_id,
+          embedding,
+          document,
+          cmetadata,
+          custom_id,
+          uuid
+      ) VALUES (
+          :1,
+          TO_VECTOR(:2),
+          :3,
+          :4,
+          :5,
+          :6
+      )
+      """, [
+        collection["uuid"],
+        self.generate_embedding(documentation),
+        question_documentation_json,
+        json.dumps(self.cmetadata),
+        custom_id,
+        id
+      ]
+    )
+    self.oracle_conn.commit()
+    cursor.close()
+    return id
+
+  def get_training_data(self, **kwargs) -> pd.DataFrame:
+    df = pd.DataFrame()
+
+    cursor = self.oracle_conn.cursor()
+    sql_collection = self.get_collection(self.sql_collection)
+    cursor.execute(
+      """
+                    SELECT
+                        document,
+                        uuid
+                    FROM oracle_embedding
+                    WHERE
+                        collection_id = :1
+                  """, [
+        sql_collection["uuid"]
+      ]
+    )
+    sql_data = cursor.fetchall()
+
+    if sql_data is not None:
+      # Extract the documents and ids
+      documents = [row_data[0] for row_data in sql_data]
+      ids = [row_data[1] for row_data in sql_data]
+
+      # Create a DataFrame
+      df_sql = pd.DataFrame(
+        {
+          "id": ids,
+          "question": [
+            json.loads(doc)["question"] if isinstance(doc,
+                                                      str) else
+            doc[
+              "question"] for doc in documents],
+          "content": [
+            json.loads(doc)["sql"] if isinstance(doc, str) else
+            doc["sql"] for
+            doc in documents],
+        }
+      )
+      df_sql["training_data_type"] = "sql"
+      df = pd.concat([df, df_sql])
+
+    ddl_collection = self.get_collection(self.ddl_collection)
+    cursor.execute(
+      """
+          SELECT
+              document,
+              uuid
+          FROM oracle_embedding
+          WHERE
+              collection_id = :1
+      """, [ddl_collection["uuid"]])
+    ddl_data = cursor.fetchall()
+
+    if ddl_data is not None:
+      # Extract the documents and ids
+      documents = [row_data[0] for row_data in ddl_data]
+      ids = [row_data[1] for row_data in ddl_data]
+
+      # Create a DataFrame
+      df_ddl = pd.DataFrame(
+        {
+          "id": ids,
+          "question": [None for _ in documents],
+          "content": [
+            json.loads(doc)["ddl"] if isinstance(doc, str) else
+            doc["ddl"] for
+            doc in documents],
+        }
+      )
+      df_ddl["training_data_type"] = "ddl"
+      df = pd.concat([df, df_ddl])
+
+    doc_collection = self.get_collection(self.documentation_collection)
+    cursor.execute(
+      """
+          SELECT
+              document,
+              uuid
+          FROM oracle_embedding
+          WHERE
+              collection_id = :1
+      """, [doc_collection["uuid"]])
+    doc_data = cursor.fetchall()
+
+    if doc_data is not None:
+      # Extract the documents and ids
+      documents = [row_data[0] for row_data in doc_data]
+      ids = [row_data[1] for row_data in doc_data]
+
+      # Create a DataFrame
+      df_doc = pd.DataFrame(
+        {
+          "id": ids,
+          "question": [None for _ in documents],
+          "content": [
+            json.loads(doc)["documentation"] if isinstance(doc,
+                                                           str) else
+            doc[
+              "documentation"] for
+            doc in documents],
+        }
+      )
+      df_doc["training_data_type"] = "documentation"
+      df = pd.concat([df, df_doc])
+
+    self.oracle_conn.commit()
+    cursor.close()
+    return df
+
+  def remove_training_data(self, id: str, **kwargs) -> bool:
+    cursor = self.oracle_conn.cursor()
+    cursor.execute(
+      """
+          DELETE
+          FROM
+              oracle_embedding
+          WHERE
+          uuid  = :1
+      """, [id])
+
+    self.oracle_conn.commit()
+    cursor.close()
+    return True
+
+  def update_training_data(self, id: str, train_type: str, question: str,
+                           **kwargs) -> bool:
+    print(f"{train_type=}")
+    update_content = kwargs["content"]
+    if train_type == 'sql':
+      update_json = json.dumps(
+        {
+          "question": question,
+          "sql": update_content,
+        }
+      )
+    elif train_type == 'ddl':
+      update_json = json.dumps(
+        {
+          "question": None,
+          "ddl": update_content,
+        }
+      )
+    elif train_type == 'documentation':
+      update_json = json.dumps(
+        {
+          "question": None,
+          "documentation": update_content,
+        }
+      )
+    else:
+      update_json = json.dumps(
+        {
+          "question": question,
+          "sql": update_content,
+        }
+      )
+    cursor = self.oracle_conn.cursor()
+    cursor.setinputsizes(oracledb.DB_TYPE_VECTOR, oracledb.DB_TYPE_JSON)
+    cursor.execute(
+      """
+                  UPDATE
+                      oracle_embedding
+                  SET
+                      embedding = TO_VECTOR(:1),
+                      document = JSON_MERGEPATCH(document, :2)
+                  WHERE
+                  uuid  = :3
+                  """, [
+        self.generate_embedding(update_content),
+        update_json,
+        id
+      ]
+    )
+
+    self.oracle_conn.commit()
+    cursor.close()
+    return True
+
+  @staticmethod
+  def _extract_documents(query_results) -> list:
+    """
+    Static method to extract the documents from the results of a query.
+
+    Args:
+        query_results (pd.DataFrame): The dataframe to use.
+
+    Returns:
+        List[str] or None: The extracted documents, or an empty list or single document if an error occurred.
+    """
+    if query_results is None or len(query_results) == 0:
+      return []
+
+    documents = [
+      json.loads(row_data[0]) if isinstance(row_data[0], str) else
+      row_data[0]
+      for row_data in query_results]
+
+    return documents
+
+  def get_similar_question_sql(self, question: str, **kwargs) -> list:
+    embeddings = self.generate_embedding(question)
+    collection = self.get_collection(self.sql_collection)
+    cursor = self.oracle_conn.cursor()
+    cursor.setinputsizes(None, oracledb.DB_TYPE_VECTOR,
+                         oracledb.DB_TYPE_VECTOR)
+    cursor.execute(
+      """
+      SELECT document
+      FROM oracle_embedding
+      WHERE collection_id = :1
+      ORDER BY VECTOR_DISTANCE(embedding, TO_VECTOR(:2), COSINE)
+      FETCH FIRST :3 ROWS ONLY
+      """, [
+        collection["uuid"],
+        embeddings,
+        self.n_results_sql
+      ]
+    )
+    results = cursor.fetchall()
+    cursor.close()
+    return self._extract_documents(results)
+
+  def get_related_ddl(self, question: str, **kwargs) -> list:
+    collection = self.get_collection(self.ddl_collection)
+    cursor = self.oracle_conn.cursor()
+    cursor.setinputsizes(None, oracledb.DB_TYPE_VECTOR)
+    cursor.execute(
+      """
+          SELECT
+              document
+          FROM oracle_embedding
+          WHERE
+              collection_id = :1
+          ORDER BY VECTOR_DISTANCE(embedding, TO_VECTOR(:2), COSINE)
+          FETCH FIRST :top_k ROWS ONLY
+      """, [
+        collection["uuid"],
+        self.generate_embedding(question),
+        100
+      ]
+    )
+    results = cursor.fetchall()
+
+    self.oracle_conn.commit()
+    cursor.close()
+    return Oracle_VectorStore._extract_documents(results)
+
+  def search_tables_metadata(self,
+                             engine: str = None,
+                             catalog: str = None,
+                             schema: str = None,
+                             table_name: str = None,
+                             ddl: str = None,
+                             size: int = 10,
+                             **kwargs) -> list:
+    pass
+
+  def get_related_documentation(self, question: str, **kwargs) -> list:
+    collection = self.get_collection(self.documentation_collection)
+    cursor = self.oracle_conn.cursor()
+    cursor.setinputsizes(None, oracledb.DB_TYPE_VECTOR)
+    cursor.execute(
+      """
+          SELECT
+              document
+          FROM oracle_embedding
+          WHERE
+              collection_id = :1
+          ORDER BY VECTOR_DISTANCE(embedding, TO_VECTOR(:2), DOT)
+          FETCH FIRST :top_k ROWS ONLY
+      """, [
+        collection["uuid"],
+        self.generate_embedding(question),
+        100
+      ]
+    )
+    results = cursor.fetchall()
+
+    self.oracle_conn.commit()
+    cursor.close()
+
+    return Oracle_VectorStore._extract_documents(results)
+
+  def create_tables_if_not_exists(self) -> None:
+    cursor = self.oracle_conn.cursor()
+    cursor.execute(
+      """
+          CREATE TABLE IF NOT EXISTS oracle_collection (
+              name      VARCHAR2(200) NOT NULL,
+              cmetadata json NOT NULL,
+              uuid      VARCHAR2(200) NOT NULL,
+              CONSTRAINT oc_key_uuid PRIMARY KEY ( uuid )
+          )
+      """
+    )
+
+    cursor.execute(
+      """
+          CREATE TABLE IF NOT EXISTS oracle_embedding (
+              collection_id VARCHAR2(200) NOT NULL,
+              embedding     vector NOT NULL,
+              document      json NOT NULL,
+              cmetadata     json NOT NULL,
+              custom_id     VARCHAR2(200) NOT NULL,
+              uuid          VARCHAR2(200) NOT NULL,
+              CONSTRAINT oe_key_uuid PRIMARY KEY ( uuid )
+          )
+      """
+    )
+
+    self.oracle_conn.commit()
+    cursor.close()
+
+  def create_collections_if_not_exists(
+    self,
+    name: str,
+    cmetadata: Optional[dict] = None,
+  ) -> Tuple[dict, bool]:
+    """
+    Get or create a collection.
+    Returns [Collection, bool] where the bool is True if the collection was created.
+    """
+    if self.pre_delete_collection:
+      self.delete_collection(name)
+    created = False
+    collection = self.get_collection(name)
+    if collection:
+      return collection, created
+
+    cmetadata = json.dumps(
+      self.cmetadata) if cmetadata is None else json.dumps(cmetadata)
+    collection_id = str(uuid.uuid4())
+    cursor = self.oracle_conn.cursor()
+    cursor.execute(
+      """
+          INSERT INTO oracle_collection(name, cmetadata, uuid)
+          VALUES (:1, :2, :3)
+      """, [
+        name,
+        cmetadata,
+        str(collection_id)
+      ]
+    )
+
+    self.oracle_conn.commit()
+    cursor.close()
+
+    collection = {"name": name, "cmetadata": cmetadata,
+                  "uuid": collection_id}
+    created = True
+    return collection, created
+
+  def get_collection(self, name) -> Optional[dict]:
+    return self.get_by_name(name)
+
+  def get_by_name(self, name: str) -> Optional[dict]:
+    cursor = self.oracle_conn.cursor()
+    cursor.execute(
+      """
+          SELECT
+              name,
+              cmetadata,
+              uuid
+          FROM
+              oracle_collection
+          WHERE
+              name = :1
+          FETCH FIRST 1 ROWS ONLY
+      """, [name])
+
+    for row in cursor:
+      return {"name": row[0], "cmetadata": row[1], "uuid": row[2]}
+
+    return  # type: ignore
+
+  def delete_collection(self, name) -> None:
+    collection = self.get_collection(name)
+    if not collection:
+      return
+
+    cursor = self.oracle_conn.cursor()
+    cursor.execute(
+      """
+          DELETE
+          FROM
+              oracle_embedding
+          WHERE
+          collection_id = ( SELECT uuid FROM oracle_collection WHERE name = :1 )
+      """, [name])
+    cursor.execute(
+      """
+          DELETE
+          FROM
+              oracle_collection
+          WHERE
+              name = :1
+      """, [name])
+
+    self.oracle_conn.commit()
+    cursor.close()

vanna/remote.py

@@ -62,7 +62,7 @@ class VannaDefault(VannaDB_VectorStore):
 
     def submit_prompt(self, prompt, **kwargs) -> str:
         # JSON-ify the prompt
-        json_prompt = json.dumps(prompt)
+        json_prompt = json.dumps(prompt, ensure_ascii=False)
 
         params = [StringData(data=json_prompt)]
 

{vanna-0.7.5.dist-info → vanna-0.7.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: vanna
-Version: 0.7.5
+Version: 0.7.6
 Summary: Generate SQL queries from natural language
 Author-email: Zain Hoda <zain@vanna.ai>
 Requires-Python: >=3.9
@@ -52,6 +52,8 @@ Requires-Dist: boto3 ; extra == "all"
 Requires-Dist: botocore ; extra == "all"
 Requires-Dist: langchain_core ; extra == "all"
 Requires-Dist: langchain_postgres ; extra == "all"
+Requires-Dist: langchain-community ; extra == "all"
+Requires-Dist: langchain-huggingface ; extra == "all"
 Requires-Dist: xinference-client ; extra == "all"
 Requires-Dist: anthropic ; extra == "anthropic"
 Requires-Dist: azure-search-documents ; extra == "azuresearch"
@@ -79,6 +81,10 @@ Requires-Dist: httpx ; extra == "ollama"
 Requires-Dist: openai ; extra == "openai"
 Requires-Dist: opensearch-py ; extra == "opensearch"
 Requires-Dist: opensearch-dsl ; extra == "opensearch"
+Requires-Dist: langchain-community ; extra == "opensearch"
+Requires-Dist: langchain-huggingface ; extra == "opensearch"
+Requires-Dist: oracledb ; extra == "oracle"
+Requires-Dist: chromadb ; extra == "oracle"
 Requires-Dist: langchain-postgres>=0.0.12 ; extra == "pgvector"
 Requires-Dist: pinecone-client ; extra == "pinecone"
 Requires-Dist: fastembed ; extra == "pinecone"
@@ -115,6 +121,7 @@ Provides-Extra: mysql
 Provides-Extra: ollama
 Provides-Extra: openai
 Provides-Extra: opensearch
+Provides-Extra: oracle
 Provides-Extra: pgvector
 Provides-Extra: pinecone
 Provides-Extra: postgres
@@ -129,9 +136,9 @@ Provides-Extra: zhipuai
 
 
 
-| GitHub | PyPI | Documentation |
-| ------ | ---- | ------------- |
-| [![GitHub](https://img.shields.io/badge/GitHub-vanna-blue?logo=github)](https://github.com/vanna-ai/vanna) | [![PyPI](https://img.shields.io/pypi/v/vanna?logo=pypi)](https://pypi.org/project/vanna/) | [![Documentation](https://img.shields.io/badge/Documentation-vanna-blue?logo=read-the-docs)](https://vanna.ai/docs/) |
+| GitHub | PyPI | Documentation | Gurubase |
+| ------ | ---- | ------------- | -------- |
+| [![GitHub](https://img.shields.io/badge/GitHub-vanna-blue?logo=github)](https://github.com/vanna-ai/vanna) | [![PyPI](https://img.shields.io/pypi/v/vanna?logo=pypi)](https://pypi.org/project/vanna/) | [![Documentation](https://img.shields.io/badge/Documentation-vanna-blue?logo=read-the-docs)](https://vanna.ai/docs/) | [![Gurubase](https://img.shields.io/badge/Gurubase-Ask%20Vanna%20Guru-006BFF)](https://gurubase.io/g/vanna) |
 
 # Vanna
 Vanna is an MIT-licensed open-source Python RAG (Retrieval-Augmented Generation) framework for SQL generation and related functionality.
@@ -164,6 +171,46 @@ These are some of the user interfaces that we've built using Vanna. You can use
 - [vanna-ai/vanna-flask](https://github.com/vanna-ai/vanna-flask)
 - [vanna-ai/vanna-slack](https://github.com/vanna-ai/vanna-slack)
 
+## Supported LLMs
+
+- [OpenAI](https://github.com/vanna-ai/vanna/tree/main/src/vanna/openai)
+- [Anthropic](https://github.com/vanna-ai/vanna/tree/main/src/vanna/anthropic)
+- [Gemini](https://github.com/vanna-ai/vanna/blob/main/src/vanna/google/gemini_chat.py)
+- [HuggingFace](https://github.com/vanna-ai/vanna/blob/main/src/vanna/hf/hf.py)
+- [AWS Bedrock](https://github.com/vanna-ai/vanna/tree/main/src/vanna/bedrock)
+- [Ollama](https://github.com/vanna-ai/vanna/tree/main/src/vanna/ollama)
+- [Qianwen](https://github.com/vanna-ai/vanna/tree/main/src/vanna/qianwen)
+- [Qianfan](https://github.com/vanna-ai/vanna/tree/main/src/vanna/qianfan)
+- [Zhipu](https://github.com/vanna-ai/vanna/tree/main/src/vanna/ZhipuAI)
+
+## Supported VectorStores
+
+- [AzureSearch](https://github.com/vanna-ai/vanna/tree/main/src/vanna/azuresearch)
+- [Opensearch](https://github.com/vanna-ai/vanna/tree/main/src/vanna/opensearch)
+- [PgVector](https://github.com/vanna-ai/vanna/tree/main/src/vanna/pgvector)
+- [PineCone](https://github.com/vanna-ai/vanna/tree/main/src/vanna/pinecone)
+- [ChromaDB](https://github.com/vanna-ai/vanna/tree/main/src/vanna/chromadb)
+- [FAISS](https://github.com/vanna-ai/vanna/tree/main/src/vanna/faiss)
+- [Marqo](https://github.com/vanna-ai/vanna/tree/main/src/vanna/marqo)
+- [Milvus](https://github.com/vanna-ai/vanna/tree/main/src/vanna/milvus)
+- [Qdrant](https://github.com/vanna-ai/vanna/tree/main/src/vanna/qdrant)
+- [Weaviate](https://github.com/vanna-ai/vanna/tree/main/src/vanna/weaviate)
+- [Oracle](https://github.com/vanna-ai/vanna/tree/main/src/vanna/oracle)
+
+## Supported Databases
+
+- [PostgreSQL](https://www.postgresql.org/)
+- [MySQL](https://www.mysql.com/)
+- [PrestoDB](https://prestodb.io/)
+- [Apache Hive](https://hive.apache.org/)
+- [ClickHouse](https://clickhouse.com/)
+- [Snowflake](https://www.snowflake.com/en/)
+- [Oracle](https://www.oracle.com/)
+- [Microsoft SQL Server](https://www.microsoft.com/en-us/sql-server/sql-server-downloads)
+- [BigQuery](https://cloud.google.com/bigquery)
+- [SQLite](https://www.sqlite.org/)
+- [DuckDB](https://duckdb.org/)
+
 
 ## Getting started
 See the [documentation](https://vanna.ai/docs/) for specifics on your desired database, LLM, etc.

{vanna-0.7.5.dist-info → vanna-0.7.6.dist-info}/RECORD

@@ -1,6 +1,6 @@
 vanna/__init__.py,sha256=4zz2kSkVZenjwJQg-ETWsIVYdz3gio275i9DMa_aHxM,9248
 vanna/local.py,sha256=U5s8ybCRQhBUizi8I69o3jqOpTeu_6KGYY6DMwZxjG4,313
-vanna/remote.py,sha256=CcScbeEkqYlzBZJMeMLDlLgmaFcG0QSUQUZybFI3Y28,1856
+vanna/remote.py,sha256=3SGyXBmNWofkZL3vGevypvMAhqAYru0KzoUCpX2N6Vc,1876
 vanna/utils.py,sha256=cs0B_0MwhmPI2nWjVHifDYCmCR0kkddylQ2vloaPDSw,2247
 vanna/ZhipuAI/ZhipuAI_Chat.py,sha256=WtZKUBIwlNH0BGbb4lZbVR7pTWIrn7b4RLIk-7u0SuQ,8725
 vanna/ZhipuAI/ZhipuAI_embeddings.py,sha256=lUqzJg9fOx7rVFhjdkFjXcDeVGV4aAB5Ss0oERsa8pE,2849
@@ -11,11 +11,13 @@ vanna/anthropic/anthropic_chat.py,sha256=7X3x8SYwDY28aGyBnt0YNRMG8YY1p_t-foMfKGj
 vanna/azuresearch/__init__.py,sha256=tZfvsrCJESiL3EnxA4PrOc5NoO8MXEzCfHX_hnj8n-c,58
 vanna/azuresearch/azuresearch_vector.py,sha256=_-t53PUnJM914GYbTYlyee06ocfu7l2NkZerBQtlJcs,9566
 vanna/base/__init__.py,sha256=Sl-HM1RRYzAZoSqmL1CZQmF3ZF-byYTCFQP3JZ2A5MU,28
-vanna/base/base.py,sha256=j5xQmK-MeFKAuPjgYLSl1ThCHZieG-ab-RFFSkDlbiw,73679
+vanna/base/base.py,sha256=dGSOuidPBCUOuKxCJ9U_B9qSQ7w5Y4XIM0olox9RCYY,73816
 vanna/bedrock/__init__.py,sha256=hRT2bgJbHEqViLdL-t9hfjSfFdIOkPU2ADBt-B1En-8,46
 vanna/bedrock/bedrock_converse.py,sha256=Nx5kYm-diAfYmsWAnTP5xnv7V84Og69-AP9b3seIe0E,2869
 vanna/chromadb/__init__.py,sha256=-iL0nW_g4uM8nWKMuWnNePfN4nb9uk8P3WzGvezOqRg,50
 vanna/chromadb/chromadb_vector.py,sha256=eKyPck99Y6Jt-BNWojvxLG-zvAERzLSm-3zY-bKXvaA,8792
+vanna/deepseek/__init__.py,sha256=7SVY3DGJcNH7GTk7Uq922QM8yZKu3-5IO33WQ_-bgCM,40
+vanna/deepseek/deepseek_chat.py,sha256=dbTIfVSNmPKYJVI8YeJu3a2Du8U6VqDHdT0gOeqISTc,1878
 vanna/exceptions/__init__.py,sha256=dJ65xxxZh1lqBeg6nz6Tq_r34jLVmjvBvPO9Q6hFaQ8,685
 vanna/faiss/__init__.py,sha256=MXuojmLPt4kUtkES9XKWJcCDHVa4L5a6YF5gebhmKLw,24
 vanna/faiss/faiss.py,sha256=HLUO5PQdnJio9OXJiJcgmRuxVWXvg_XRBnnohS21Z0w,8304
@@ -24,7 +26,7 @@ vanna/flask/assets.py,sha256=af-vact_5HSftltugBpPxzLkAI14Z0lVWcObyVe6eKE,453462
 vanna/flask/auth.py,sha256=UpKxh7W5cd43W0LGch0VqhncKwB78L6dtOQkl1JY5T0,1246
 vanna/google/__init__.py,sha256=6D8rDBjKJJm_jpVn9b4Vc2NR-R779ed_bnHhWmxCJXE,92
 vanna/google/bigquery_vector.py,sha256=mHggjvCsWMt4HK6Y4dAZUPgHi1uytxp2AEQ696TSsJA,9315
-vanna/google/gemini_chat.py,sha256=9xHvxArxHr7OWXHnDRz7wX7KTGbuy6xXxHMLkhOMkis,1568
+vanna/google/gemini_chat.py,sha256=Tm4S0uywQNuZ5y0eQsE0-rv0NkAw_IhlyMiQqiqn8ro,2683
 vanna/hf/__init__.py,sha256=vD0bIhfLkA1UsvVSF4MAz3Da8aQunkQo3wlDztmMuj0,19
 vanna/hf/hf.py,sha256=N8N5g3xvKDBt3dez2r_U0qATxbl2pN8SVLTZK9CSRA0,3020
 vanna/marqo/__init__.py,sha256=GaAWtJ0B-H5rTY607iLCCrLD7T0zMYM5qWIomEB9gLk,37
@@ -38,12 +40,15 @@ vanna/mock/embedding.py,sha256=ggnP7KuPh6dlqeUFtoN8t0J0P7_yRNtn9rIq6h8g8-w,250
 vanna/mock/llm.py,sha256=WpG9f1pKZftPBHqgIYdARKB2Z9DZhOALYOJWoOjjFEc,518
 vanna/mock/vectordb.py,sha256=h45znfYMUnttE2BBC8v6TKeMaA58pFJL-5B3OGeRNFI,2681
 vanna/ollama/__init__.py,sha256=4xyu8aHPdnEHg5a-QAMwr5o0ns5wevsp_zkI-ndMO2k,27
-vanna/ollama/ollama.py,sha256=yD7UHn4GNzWfQMi2OHlfWwIEJ_sTDzpPcgv_MCGRp6E,3871
+vanna/ollama/ollama.py,sha256=pqHkh2UEIAwBqxRebsLVmmkpiF30yRwCwO_92WY4p0E,3891
 vanna/openai/__init__.py,sha256=tGkeQ7wTIPsando7QhoSHehtoQVdYLwFbKNlSmCmNeQ,86
 vanna/openai/openai_chat.py,sha256=KU6ynOQ5v7vwrQQ13phXoUXeQUrH6_vmhfiPvWddTrQ,4427
 vanna/openai/openai_embeddings.py,sha256=g4pNh9LVcYP9wOoO8ecaccDFWmCUYMInebfHucAa2Gc,1260
-vanna/opensearch/__init__.py,sha256=0unDevWOTs7o8S79TOHUKF1mSiuQbBUVm-7k9jV5WW4,54
+vanna/opensearch/__init__.py,sha256=dc9fNtIrOOpkSGp_JKOhGOk26ffyK6W1bm_Cdn9X09I,126
 vanna/opensearch/opensearch_vector.py,sha256=VhIcrSyNzWR9ZrqrJnyGFOyuQZs3swfbhr8QyVGI0eI,12226
+vanna/opensearch/opensearch_vector_semantic.py,sha256=XV0ApIMXTj_dc3tnmTg4vkQXMaUxsh2Npk_JBEGIj1Q,6325
+vanna/oracle/__init__.py,sha256=lE9IB9nK4wsAQ0KdAqoidMoLH80QBsB1HRbI0GQJh8c,46
+vanna/oracle/oracle_vector.py,sha256=uWcDFs5uhdKdjdEhFXy4RouTOiS-XMFmaUFuuOLtqho,15974
 vanna/pgvector/__init__.py,sha256=7Wvu9qcNdNvZu26Dn53jhO9YXELm0_YsrwBab4BdgVM,37
 vanna/pgvector/pgvector.py,sha256=dJfm8rswYZvbaIbnjmyRjL071iw4siE0INibsZtaLXY,9919
 vanna/pinecone/__init__.py,sha256=eO5l8aX8vKL6aIUMgAXGPt1jdqKxB_Hic6cmoVAUrD0,90
@@ -65,6 +70,6 @@ vanna/weaviate/__init__.py,sha256=HL6PAl7ePBAkeG8uln-BmM7IUtWohyTPvDfcPzSGSCg,46
 vanna/weaviate/weaviate_vector.py,sha256=tUJIZjEy2mda8CB6C8zeN2SKkEO-UJdLsIqy69skuF0,7584
 vanna/xinference/__init__.py,sha256=EFW_sz-BSB2XgmjACOTZmneeIk3I2EiWgue-VVJpnB0,35
 vanna/xinference/xinference.py,sha256=2PI-f7XoBUyL_jfuXPqxCsd0W72h8j6CtEDneFw1AtI,1876
-vanna-0.7.5.dist-info/WHEEL,sha256=EZbGkh7Ie4PoZfRQ8I0ZuP9VklN_TvcZ6DSE5Uar4z4,81
-vanna-0.7.5.dist-info/METADATA,sha256=ps3MrKa5oG8XfjgG6C5u71v3OExvket22gu8uMwtufs,13048
-vanna-0.7.5.dist-info/RECORD,,
+vanna-0.7.6.dist-info/WHEEL,sha256=CpUCUxeHQbRN5UGRQHYRJorO5Af-Qy_fHMctcQ8DSGI,82
+vanna-0.7.6.dist-info/METADATA,sha256=hXqEvvTbOUOs9ZkGYNSkxvPYHb4kZE7JDfDyGGZt5q4,15600
+vanna-0.7.6.dist-info/RECORD,,

{vanna-0.7.5.dist-info → vanna-0.7.6.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: flit 3.9.0
+Generator: flit 3.10.1
 Root-Is-Purelib: true
 Tag: py3-none-any