vanna 0.6.5__py3-none-any.whl → 0.7.0__py3-none-any.whl

vanna/google/__init__.py

@@ -1 +1,2 @@
-from .gemini_chat import GoogleGeminiChat
+from .bigquery_vector import BigQuery_VectorStore
+from .gemini_chat import GoogleGeminiChat

vanna/google/bigquery_vector.py

@@ -0,0 +1,230 @@
+import datetime
+import os
+import uuid
+from typing import List, Optional
+
+import pandas as pd
+from google.cloud import bigquery
+
+from ..base import VannaBase
+
+
+class BigQuery_VectorStore(VannaBase):
+    def __init__(self, config: dict, **kwargs):
+        self.config = config
+
+        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))
+
+        if "api_key" in config or os.getenv("GOOGLE_API_KEY"):
+            """
+            If Google api_key is provided through config
+            or set as an environment variable, assign it.
+            """
+            print("Configuring genai")
+            import google.generativeai as genai
+
+            genai.configure(api_key=config["api_key"])
+
+            self.genai = genai
+        else:
+            # Authenticate using VertexAI
+            from vertexai.language_models import (
+              TextEmbeddingInput,
+              TextEmbeddingModel,
+            )
+
+        if self.config.get("project_id"):
+            self.project_id = self.config.get("project_id")
+        else:
+            self.project_id = os.getenv("GOOGLE_CLOUD_PROJECT")
+
+        if self.project_id is None:
+            raise ValueError("Project ID is not set")
+
+        self.conn = bigquery.Client(project=self.project_id)
+
+        dataset_name = self.config.get('bigquery_dataset_name', 'vanna_managed')
+        self.dataset_id = f"{self.project_id}.{dataset_name}"
+        dataset = bigquery.Dataset(self.dataset_id)
+
+        try:
+            self.conn.get_dataset(self.dataset_id)  # Make an API request.
+            print(f"Dataset {self.dataset_id} already exists")
+        except Exception:
+            # Dataset does not exist, create it
+            dataset.location = "US"
+            self.conn.create_dataset(dataset, timeout=30)  # Make an API request.
+            print(f"Created dataset {self.dataset_id}")
+
+        # Create a table called training_data in the dataset that contains the columns:
+        # id, training_data_type, question, content, embedding, created_at
+
+        self.table_id = f"{self.dataset_id}.training_data"
+        schema = [
+            bigquery.SchemaField("id", "STRING", mode="REQUIRED"),
+            bigquery.SchemaField("training_data_type", "STRING", mode="REQUIRED"),
+            bigquery.SchemaField("question", "STRING", mode="REQUIRED"),
+            bigquery.SchemaField("content", "STRING", mode="REQUIRED"),
+            bigquery.SchemaField("embedding", "FLOAT64", mode="REPEATED"),
+            bigquery.SchemaField("created_at", "TIMESTAMP", mode="REQUIRED"),
+        ]
+
+        table = bigquery.Table(self.table_id, schema=schema)
+
+        try:
+            self.conn.get_table(self.table_id)  # Make an API request.
+            print(f"Table {self.table_id} already exists")
+        except Exception:
+            # Table does not exist, create it
+            self.conn.create_table(table, timeout=30)  # Make an API request.
+            print(f"Created table {self.table_id}")
+
+        # Create VECTOR INDEX IF NOT EXISTS
+        # TODO: This requires 5000 rows before it can be created
+        # vector_index_query = f"""
+        # CREATE VECTOR INDEX IF NOT EXISTS my_index
+        # ON `{self.table_id}`(embedding)
+        # OPTIONS(
+        #     distance_type='COSINE',
+        #     index_type='IVF',
+        #     ivf_options='{{"num_lists": 1000}}'
+        # )
+        # """
+
+        # try:
+        #     self.conn.query(vector_index_query).result()  # Make an API request.
+        #     print(f"Vector index on {self.table_id} created or already exists")
+        # except Exception as e:
+        #     print(f"Failed to create vector index: {e}")
+
+    def store_training_data(self, training_data_type: str, question: str, content: str, embedding: List[float], **kwargs) -> str:
+        id = str(uuid.uuid4())
+        created_at = datetime.datetime.now()
+        self.conn.insert_rows_json(self.table_id, [{
+            "id": id,
+            "training_data_type": training_data_type,
+            "question": question,
+            "content": content,
+            "embedding": embedding,
+            "created_at": created_at.isoformat()
+        }])
+
+        return id
+
+    def fetch_similar_training_data(self, training_data_type: str, question: str, n_results, **kwargs) -> pd.DataFrame:
+        question_embedding = self.generate_question_embedding(question)
+
+        query = f"""
+        SELECT
+            base.id as id,
+            base.question as question,
+            base.training_data_type as training_data_type,
+            base.content as content,
+            distance
+        FROM
+            VECTOR_SEARCH(
+                TABLE `{self.table_id}`,
+                'embedding',
+                (SELECT * FROM UNNEST([STRUCT({question_embedding})])),
+                top_k => 5,
+                distance_type => 'COSINE',
+                options => '{{"use_brute_force":true}}'
+            )
+        WHERE
+            base.training_data_type = '{training_data_type}'
+        """
+
+        results = self.conn.query(query).result().to_dataframe()
+        return results
+
+    def generate_question_embedding(self, data: str, **kwargs) -> List[float]:
+        result = self.genai.embed_content(
+            model="models/text-embedding-004",
+            content=data,
+            task_type="retrieval_query")
+
+        if 'embedding' in result:
+            return result['embedding']
+        else:
+            raise ValueError("No embeddings returned")
+
+    def generate_storage_embedding(self, data: str, **kwargs) -> List[float]:
+        result = self.genai.embed_content(
+            model="models/text-embedding-004",
+            content=data,
+            task_type="retrieval_document")
+
+        if 'embedding' in result:
+            return result['embedding']
+        else:
+            raise ValueError("No embeddings returned")
+
+        # task = "RETRIEVAL_DOCUMENT"
+        # inputs = [TextEmbeddingInput(data, task)]
+        # embeddings = self.vertex_embedding_model.get_embeddings(inputs)
+
+        # if len(embeddings) == 0:
+        #     raise ValueError("No embeddings returned")
+
+        # return embeddings[0].values
+
+        return result
+
+    def generate_embedding(self, data: str, **kwargs) -> List[float]:
+        return self.generate_storage_embedding(data, **kwargs)
+
+    def get_similar_question_sql(self, question: str, **kwargs) -> list:
+        df = self.fetch_similar_training_data(training_data_type="sql", question=question, n_results=self.n_results_sql)
+
+        # Return a list of dictionaries with only question, sql fields. The content field needs to be renamed to sql
+        return df.rename(columns={"content": "sql"})[["question", "sql"]].to_dict(orient="records")
+
+    def get_related_ddl(self, question: str, **kwargs) -> list:
+        df = self.fetch_similar_training_data(training_data_type="ddl", question=question, n_results=self.n_results_ddl)
+
+        # Return a list of strings of the content
+        return df["content"].tolist()
+
+    def get_related_documentation(self, question: str, **kwargs) -> list:
+        df = self.fetch_similar_training_data(training_data_type="documentation", question=question, n_results=self.n_results_documentation)
+
+        # Return a list of strings of the content
+        return df["content"].tolist()
+
+    def add_question_sql(self, question: str, sql: str, **kwargs) -> str:
+        doc = {
+            "question": question,
+            "sql": sql
+        }
+
+        embedding = self.generate_embedding(str(doc))
+
+        return self.store_training_data(training_data_type="sql", question=question, content=sql, embedding=embedding)
+
+    def add_ddl(self, ddl: str, **kwargs) -> str:
+        embedding = self.generate_embedding(ddl)
+
+        return self.store_training_data(training_data_type="ddl", question="", content=ddl, embedding=embedding)
+
+    def add_documentation(self, documentation: str, **kwargs) -> str:
+        embedding = self.generate_embedding(documentation)
+
+        return self.store_training_data(training_data_type="documentation", question="", content=documentation, embedding=embedding)
+
+    def get_training_data(self, **kwargs) -> pd.DataFrame:
+        query = f"SELECT id, training_data_type, question, content FROM `{self.table_id}`"
+
+        return self.conn.query(query).result().to_dataframe()
+
+    def remove_training_data(self, id: str, **kwargs) -> bool:
+        query = f"DELETE FROM `{self.table_id}` WHERE id = '{id}'"
+
+        try:
+            self.conn.query(query).result()
+            return True
+
+        except Exception as e:
+            print(f"Failed to remove training data: {e}")
+            return False

vanna/mistral/mistral.py

@@ -1,5 +1,7 @@
-from mistralai.client import MistralClient
-from mistralai.models.chat_completion import ChatMessage
+import os
+
+from mistralai import Mistral as MistralClient
+from mistralai import UserMessage
 
 from ..base import VannaBase
 
@@ -23,13 +25,13 @@ class Mistral(VannaBase):
         self.model = model
 
     def system_message(self, message: str) -> any:
-        return ChatMessage(role="system", content=message)
+        return {"role": "system", "content": message}
 
     def user_message(self, message: str) -> any:
-        return ChatMessage(role="user", content=message)
+        return {"role": "user", "content": message}
 
     def assistant_message(self, message: str) -> any:
-        return ChatMessage(role="assistant", content=message)
+        return {"role": "assistant", "content": message}
 
     def generate_sql(self, question: str, **kwargs) -> str:
         # Use the super generate_sql
@@ -41,7 +43,7 @@ class Mistral(VannaBase):
         return sql
 
     def submit_prompt(self, prompt, **kwargs) -> str:
-        chat_response = self.client.chat(
+        chat_response = self.client.chat.complete(
             model=self.model,
             messages=prompt,
         )

vanna/ollama/ollama.py

@@ -27,7 +27,9 @@ class Ollama(VannaBase):
     if ":" not in self.model:
       self.model += ":latest"
 
-    self.ollama_client = ollama.Client(self.host, timeout=Timeout(240.0))
+    self.ollama_timeout = config.get("ollama_timeout", 240.0)
+
+    self.ollama_client = ollama.Client(self.host, timeout=Timeout(self.ollama_timeout))
     self.keep_alive = config.get('keep_alive', None)
     self.ollama_options = config.get('options', {})
     self.num_ctx = self.ollama_options.get('num_ctx', 2048)

vanna/qianwen/QianwenAI_chat.py

@@ -0,0 +1,133 @@
+import os
+
+from openai import OpenAI
+
+from ..base import VannaBase
+
+
+class QianWenAI_Chat(VannaBase):
+  def __init__(self, client=None, config=None):
+    VannaBase.__init__(self, config=config)
+
+    # default parameters - can be overrided using config
+    self.temperature = 0.7
+
+    if "temperature" in config:
+      self.temperature = config["temperature"]
+
+    if "api_type" in config:
+      raise Exception(
+        "Passing api_type is now deprecated. Please pass an OpenAI client instead."
+      )
+
+    if "api_base" in config:
+      raise Exception(
+        "Passing api_base is now deprecated. Please pass an OpenAI client instead."
+      )
+
+    if "api_version" in config:
+      raise Exception(
+        "Passing api_version is now deprecated. Please pass an OpenAI client instead."
+      )
+
+    if client is not None:
+      self.client = client
+      return
+
+    if config is None and client is None:
+      self.client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
+      return
+
+    if "api_key" in config:
+      if "base_url" not in config:
+        self.client = OpenAI(api_key=config["api_key"],
+                             base_url="https://dashscope.aliyuncs.com/compatible-mode/v1")
+      else:
+        self.client = OpenAI(api_key=config["api_key"],
+                             base_url=config["base_url"])
+
+  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:
+    if prompt is None:
+      raise Exception("Prompt is None")
+
+    if len(prompt) == 0:
+      raise Exception("Prompt is empty")
+
+    # Count the number of tokens in the message log
+    # Use 4 as an approximation for the number of characters per token
+    num_tokens = 0
+    for message in prompt:
+      num_tokens += len(message["content"]) / 4
+
+    if kwargs.get("model", None) is not None:
+      model = kwargs.get("model", None)
+      print(
+        f"Using model {model} for {num_tokens} tokens (approx)"
+      )
+      response = self.client.chat.completions.create(
+        model=model,
+        messages=prompt,
+        stop=None,
+        temperature=self.temperature,
+      )
+    elif kwargs.get("engine", None) is not None:
+      engine = kwargs.get("engine", None)
+      print(
+        f"Using model {engine} for {num_tokens} tokens (approx)"
+      )
+      response = self.client.chat.completions.create(
+        engine=engine,
+        messages=prompt,
+        stop=None,
+        temperature=self.temperature,
+      )
+    elif self.config is not None and "engine" in self.config:
+      print(
+        f"Using engine {self.config['engine']} for {num_tokens} tokens (approx)"
+      )
+      response = self.client.chat.completions.create(
+        engine=self.config["engine"],
+        messages=prompt,
+        stop=None,
+        temperature=self.temperature,
+      )
+    elif self.config is not None and "model" in self.config:
+      print(
+        f"Using model {self.config['model']} for {num_tokens} tokens (approx)"
+      )
+      response = self.client.chat.completions.create(
+        model=self.config["model"],
+        messages=prompt,
+        stop=None,
+        temperature=self.temperature,
+      )
+    else:
+      if num_tokens > 3500:
+        model = "qwen-long"
+      else:
+        model = "qwen-plus"
+
+      print(f"Using model {model} for {num_tokens} tokens (approx)")
+      response = self.client.chat.completions.create(
+        model=model,
+        messages=prompt,
+        stop=None,
+        temperature=self.temperature,
+      )
+
+    # Find the first response from the chatbot that has text in it (some responses may not have text)
+    for choice in response.choices:
+      if "text" in choice:
+        return choice.text
+
+    # If no response with text is found, return the first response's content (which may be empty)
+    return response.choices[0].message.content

vanna/qianwen/QianwenAI_embeddings.py

@@ -0,0 +1,46 @@
+from openai import OpenAI
+
+from ..base import VannaBase
+
+
+class QianWenAI_Embeddings(VannaBase):
+    def __init__(self, client=None, config=None):
+        VannaBase.__init__(self, config=config)
+
+        if client is not None:
+            self.client = client
+            return
+
+        if self.client is not None:
+            return
+
+        self.client = OpenAI()
+
+        if config is None:
+            return
+
+        if "api_type" in config:
+            self.client.api_type = config["api_type"]
+
+        if "api_base" in config:
+            self.client.api_base = config["api_base"]
+
+        if "api_version" in config:
+            self.client.api_version = config["api_version"]
+
+        if "api_key" in config:
+            self.client.api_key = config["api_key"]
+
+    def generate_embedding(self, data: str, **kwargs) -> list[float]:
+        if self.config is not None and "engine" in self.config:
+            embedding = self.client.embeddings.create(
+                engine=self.config["engine"],
+                input=data,
+            )
+        else:
+            embedding = self.client.embeddings.create(
+                model="bge-large-zh",
+                input=data,
+            )
+
+        return embedding.get("data")[0]["embedding"]

vanna/qianwen/__init__.py

@@ -0,0 +1,2 @@
+from .QianwenAI_chat import QianWenAI_Chat
+from .QianwenAI_embeddings import QianWenAI_Embeddings

{vanna-0.6.5.dist-info → vanna-0.7.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vanna
-Version: 0.6.5
+Version: 0.7.0
 Summary: Generate SQL queries from natural language
 Author-email: Zain Hoda <zain@vanna.ai>
 Requires-Python: >=3.9
@@ -26,7 +26,7 @@ Requires-Dist: snowflake-connector-python ; extra == "all"
 Requires-Dist: duckdb ; extra == "all"
 Requires-Dist: openai ; extra == "all"
 Requires-Dist: qianfan ; extra == "all"
-Requires-Dist: mistralai ; extra == "all"
+Requires-Dist: mistralai>=1.0.0 ; extra == "all"
 Requires-Dist: chromadb ; extra == "all"
 Requires-Dist: anthropic ; extra == "all"
 Requires-Dist: zhipuai ; extra == "all"
@@ -43,7 +43,14 @@ Requires-Dist: transformers ; extra == "all"
 Requires-Dist: pinecone-client ; extra == "all"
 Requires-Dist: pymilvus[model] ; extra == "all"
 Requires-Dist: weaviate-client ; extra == "all"
+Requires-Dist: azure-search-documents ; extra == "all"
+Requires-Dist: azure-identity ; extra == "all"
+Requires-Dist: azure-common ; extra == "all"
 Requires-Dist: anthropic ; extra == "anthropic"
+Requires-Dist: azure-search-documents ; extra == "azuresearch"
+Requires-Dist: azure-identity ; extra == "azuresearch"
+Requires-Dist: azure-common ; extra == "azuresearch"
+Requires-Dist: fastembed ; extra == "azuresearch"
 Requires-Dist: boto3 ; extra == "bedrock"
 Requires-Dist: botocore ; extra == "bedrock"
 Requires-Dist: google-cloud-bigquery ; extra == "bigquery"
@@ -56,7 +63,7 @@ Requires-Dist: google-cloud-aiplatform ; extra == "google"
 Requires-Dist: transformers ; extra == "hf"
 Requires-Dist: marqo ; extra == "marqo"
 Requires-Dist: pymilvus[model] ; extra == "milvus"
-Requires-Dist: mistralai ; extra == "mistralai"
+Requires-Dist: mistralai>=1.0.0 ; extra == "mistralai"
 Requires-Dist: PyMySQL ; extra == "mysql"
 Requires-Dist: ollama ; extra == "ollama"
 Requires-Dist: httpx ; extra == "ollama"
@@ -79,6 +86,7 @@ Project-URL: Bug Tracker, https://github.com/vanna-ai/vanna/issues
 Project-URL: Homepage, https://github.com/vanna-ai/vanna
 Provides-Extra: all
 Provides-Extra: anthropic
+Provides-Extra: azuresearch
 Provides-Extra: bedrock
 Provides-Extra: bigquery
 Provides-Extra: chromadb

{vanna-0.6.5.dist-info → vanna-0.7.0.dist-info}/RECORD

@@ -8,17 +8,20 @@ vanna/ZhipuAI/__init__.py,sha256=NlsijtcZp5Tj9jkOe9fNcOQND_QsGgu7otODsCLBPr0,116
 vanna/advanced/__init__.py,sha256=oDj9g1JbrbCfp4WWdlr_bhgdMqNleyHgr6VXX6DcEbo,658
 vanna/anthropic/__init__.py,sha256=85s_2mAyyPxc0T_0JEvYeAkEKWJwkwqoyUwSC5dw9Gk,43
 vanna/anthropic/anthropic_chat.py,sha256=7X3x8SYwDY28aGyBnt0YNRMG8YY1p_t-foMfKGj8_Oo,2627
+vanna/azuresearch/__init__.py,sha256=tZfvsrCJESiL3EnxA4PrOc5NoO8MXEzCfHX_hnj8n-c,58
+vanna/azuresearch/azuresearch_vector.py,sha256=fc7w_bE6IgOsWb1vkA8t8k-AtuzLyH6zlW4ej4d2lE8,9558
 vanna/base/__init__.py,sha256=Sl-HM1RRYzAZoSqmL1CZQmF3ZF-byYTCFQP3JZ2A5MU,28
-vanna/base/base.py,sha256=3Du70NrXQMn_LOif2YFPRRVKo4wH5-f6eZcLlXEX0X8,71705
+vanna/base/base.py,sha256=j5xQmK-MeFKAuPjgYLSl1ThCHZieG-ab-RFFSkDlbiw,73679
 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/exceptions/__init__.py,sha256=dJ65xxxZh1lqBeg6nz6Tq_r34jLVmjvBvPO9Q6hFaQ8,685
-vanna/flask/__init__.py,sha256=r1ucQupb6wuTcjVVKpkdrg6R38FZe6KQoKw9AtcghDQ,42889
-vanna/flask/assets.py,sha256=_UoUr57sS0QL2BuTxAOe9k4yy8T7-fp2NpbRSVtW3IM,451769
+vanna/flask/__init__.py,sha256=jcdaau1tQ142nL1ZsDklk0ilMkEyRxgQZdmsl1IN4LQ,43866
+vanna/flask/assets.py,sha256=af-vact_5HSftltugBpPxzLkAI14Z0lVWcObyVe6eKE,453462
 vanna/flask/auth.py,sha256=UpKxh7W5cd43W0LGch0VqhncKwB78L6dtOQkl1JY5T0,1246
-vanna/google/__init__.py,sha256=M-dCxCZcKL4bTQyMLj6r6VRs65YNX9Tl2aoPCuqGm-8,41
+vanna/google/__init__.py,sha256=6D8rDBjKJJm_jpVn9b4Vc2NR-R779ed_bnHhWmxCJXE,92
+vanna/google/bigquery_vector.py,sha256=rkP94Xd1lNYjU1x3MDLvqmGSPUYtDfQwvlqVmX44jyM,8839
 vanna/google/gemini_chat.py,sha256=j1szC2PamMLFrs0Z4lYPS69i017FYICe-mNObNYFBPQ,1576
 vanna/hf/__init__.py,sha256=vD0bIhfLkA1UsvVSF4MAz3Da8aQunkQo3wlDztmMuj0,19
 vanna/hf/hf.py,sha256=N8N5g3xvKDBt3dez2r_U0qATxbl2pN8SVLTZK9CSRA0,3020
@@ -27,13 +30,13 @@ vanna/marqo/marqo.py,sha256=W7WTtzWp4RJjZVy6OaXHqncUBIPdI4Q7qH7BRCxZ1_A,5242
 vanna/milvus/__init__.py,sha256=VBasJG2eTKbJI6CEand7kPLNBrqYrn0QCAhSYVz814s,46
 vanna/milvus/milvus_vector.py,sha256=Mq0eaSh0UcTYhgh8mTm0fvS6rbfL6tQONVnDZGemWoM,11268
 vanna/mistral/__init__.py,sha256=70rTY-69Z2ehkkMj84dNMCukPo6AWdflBGvIB_pztS0,29
-vanna/mistral/mistral.py,sha256=DAEqAT9SzC91rfMM_S3SuzBZ34MrKHw9qAj6EP2MGVk,1508
+vanna/mistral/mistral.py,sha256=rcdgmUSQniLkah2VL23VGYRa9WXpOy_dZN4S0kc__V8,1494
 vanna/mock/__init__.py,sha256=nYR2WfcV5NdwpK3V64QGOWHBGc3ESN9uV68JLS76aRw,97
 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=rXa7cfvdlO1E5SLysXIl3IZpIaA2r0RBvV5jX2-upiE,3794
+vanna/ollama/ollama.py,sha256=yD7UHn4GNzWfQMi2OHlfWwIEJ_sTDzpPcgv_MCGRp6E,3871
 vanna/openai/__init__.py,sha256=tGkeQ7wTIPsando7QhoSHehtoQVdYLwFbKNlSmCmNeQ,86
 vanna/openai/openai_chat.py,sha256=KU6ynOQ5v7vwrQQ13phXoUXeQUrH6_vmhfiPvWddTrQ,4427
 vanna/openai/openai_embeddings.py,sha256=g4pNh9LVcYP9wOoO8ecaccDFWmCUYMInebfHucAa2Gc,1260
@@ -46,6 +49,9 @@ vanna/qdrant/qdrant.py,sha256=qkTWhGrVSAngJZkrcRQ8YFVHcI9j_ZoOGbF6ZVUUdsU,12567
 vanna/qianfan/Qianfan_Chat.py,sha256=Z-s9MwH22T4KMR8AViAjms6qoj67pHeQkMsbK-aXf1M,5273
 vanna/qianfan/Qianfan_embeddings.py,sha256=TYynAJXlyuZfmoj49h8nU6bXu_GjlXREp3tgfQUca04,954
 vanna/qianfan/__init__.py,sha256=QpR43BjZQZcrcDRkyYcYiS-kyqtYmu23AHDzK0Wy1D0,90
+vanna/qianwen/QianwenAI_chat.py,sha256=c4stx4QzX-Af28c0H4h2ZDDKJknWcun0L9LevMTSHSE,4076
+vanna/qianwen/QianwenAI_embeddings.py,sha256=55cwKpB_N3OVgXkC8uSGQCaIAK8vojz2UnlANtiXWS8,1253
+vanna/qianwen/__init__.py,sha256=fBl4zQTpvObGRNJV6EVNjIUQ9aKDDYq-zLPsEZrRpwg,98
 vanna/types/__init__.py,sha256=Qhn_YscKtJh7mFPCyCDLa2K8a4ORLMGVnPpTbv9uB2U,4957
 vanna/vannadb/__init__.py,sha256=C6UkYocmO6dmzfPKZaWojN0mI5YlZZ9VIbdcquBE58A,48
 vanna/vannadb/vannadb_vector.py,sha256=N8poMYvAojoaOF5gI4STD5pZWK9lBKPvyIjbh9dPBa0,14189
@@ -53,6 +59,6 @@ vanna/vllm/__init__.py,sha256=aNlUkF9tbURdeXAJ8ytuaaF1gYwcG3ny1MfNl_cwQYg,23
 vanna/vllm/vllm.py,sha256=oM_aA-1Chyl7T_Qc_yRKlL6oSX1etsijY9zQdjeMGMQ,2827
 vanna/weaviate/__init__.py,sha256=HL6PAl7ePBAkeG8uln-BmM7IUtWohyTPvDfcPzSGSCg,46
 vanna/weaviate/weaviate_vector.py,sha256=GEiu4Vd9w-7j10aB-zTxJ8gefqe_F-LUUGvttFs1vlg,7539
-vanna-0.6.5.dist-info/WHEEL,sha256=EZbGkh7Ie4PoZfRQ8I0ZuP9VklN_TvcZ6DSE5Uar4z4,81
-vanna-0.6.5.dist-info/METADATA,sha256=77ggtzQplTTDdsOI0_U4k-t5UwHVmI5O3TSkpm5OXzY,11997
-vanna-0.6.5.dist-info/RECORD,,
+vanna-0.7.0.dist-info/WHEEL,sha256=EZbGkh7Ie4PoZfRQ8I0ZuP9VklN_TvcZ6DSE5Uar4z4,81
+vanna-0.7.0.dist-info/METADATA,sha256=O-4tGHTmtlFTk-JMoYMNw0S3R6rfcu8geWDIUojQ36U,12407
+vanna-0.7.0.dist-info/RECORD,,