vectara-agentic 0.3.2__py3-none-any.whl → 0.4.0__py3-none-any.whl

vectara_agentic/db_tools.py

@@ -6,6 +6,7 @@ It makes the following adjustments:
 * Makes sure the load_data method returns a list of text values from the database (and not Document[] objects).
 * Limits the returned rows to self.max_rows.
 """
+
 from typing import Any, Optional, List, Awaitable, Callable
 import asyncio
 from inspect import signature
@@ -24,15 +25,20 @@ from llama_index.core.tools.utils import create_schema_from_function
 
 AsyncCallable = Callable[..., Awaitable[Any]]
 
+
 class DatabaseTools:
     """Database tools for vectara-agentic
     This class provides a set of tools to interact with a database.
     It allows you to load data, list tables, describe tables, and load unique values.
     It also provides a method to load sample data from a specified table.
     """
+
     spec_functions = [
-        "load_data", "load_sample_data", "list_tables",
-        "describe_tables", "load_unique_values",
+        "load_data",
+        "load_sample_data",
+        "list_tables",
+        "describe_tables",
+        "load_unique_values",
     ]
 
     def __init__(
@@ -61,7 +67,7 @@ class DatabaseTools:
         elif uri:
             self.uri = uri
             self.sql_database = SQLDatabase.from_uri(uri, *args, **kwargs)
-        elif (scheme and host and port and user and password and dbname):
+        elif scheme and host and port and user and password and dbname:
             uri = f"{scheme}://{user}:{password}@{host}:{port}/{dbname}"
             self.uri = uri
             self.sql_database = SQLDatabase.from_uri(uri, *args, **kwargs)
@@ -76,7 +82,8 @@ class DatabaseTools:
         self._metadata.reflect(bind=self.sql_database.engine)
 
     def _get_metadata_from_fn_name(
-        self, fn_name: Callable,
+        self,
+        fn_name: str,
     ) -> Optional[ToolMetadata]:
         """Return map from function name.
 
@@ -87,7 +94,9 @@ class DatabaseTools:
             func = getattr(self, fn_name)
         except AttributeError:
             return None
-        name = self.tool_name_prefix + "_" + fn_name if self.tool_name_prefix else fn_name
+        name = (
+            self.tool_name_prefix + "_" + fn_name if self.tool_name_prefix else fn_name
+        )
         docstring = func.__doc__ or ""
         description = f"{name}{signature(func)}\n{docstring}"
         fn_schema = create_schema_from_function(fn_name, getattr(self, fn_name))
@@ -118,7 +127,9 @@ class DatabaseTools:
         try:
             count_rows = self._load_data(count_query)
         except Exception as e:
-            return [f"Error ({str(e)}) occurred while counting number of rows, check your query."]
+            return [
+                f"Error ({str(e)}) occurred while counting number of rows, check your query."
+            ]
         num_rows = int(count_rows[0].text)
         if num_rows > self.max_rows:
             return [
@@ -128,7 +139,9 @@ class DatabaseTools:
         try:
             res = self._load_data(sql_query)
         except Exception as e:
-            return [f"Error ({str(e)}) occurred while executing the query {sql_query}, check your query."]
+            return [
+                f"Error ({str(e)}) occurred while executing the query {sql_query}, check your query."
+            ]
         return [d.text for d in res]
 
     def load_sample_data(self, table_name: str, num_rows: int = 25) -> Any:
@@ -149,7 +162,9 @@ class DatabaseTools:
         try:
             res = self._load_data(f"SELECT * FROM {table_name} LIMIT {num_rows}")
         except Exception as e:
-            return [f"Error ({str(e)}) occurred while loading sample data for table {table_name}"]
+            return [
+                f"Error ({str(e)}) occurred while loading sample data for table {table_name}"
+            ]
         return [d.text for d in res]
 
     def list_tables(self) -> List[str]:
@@ -179,7 +194,11 @@ class DatabaseTools:
         table_schemas = []
         for table_name in table_names:
             table = next(
-                (table for table in self._metadata.sorted_tables if table.name == table_name),
+                (
+                    table
+                    for table in self._metadata.sorted_tables
+                    if table.name == table_name
+                ),
                 None,
             )
             if table is None:
@@ -188,7 +207,9 @@ class DatabaseTools:
             table_schemas.append(f"{schema}\n")
         return "\n".join(table_schemas)
 
-    def load_unique_values(self, table_name: str, columns: list[str], num_vals: int = 200) -> Any:
+    def load_unique_values(
+        self, table_name: str, columns: list[str], num_vals: int = 200
+    ) -> Any:
         """
         Fetches the first num_vals unique values from the specified columns of the database table.
 
@@ -209,10 +230,14 @@ class DatabaseTools:
         res = {}
         try:
             for column in columns:
-                unique_vals = self._load_data(f'SELECT DISTINCT "{column}" FROM {table_name} LIMIT {num_vals}')
+                unique_vals = self._load_data(
+                    f'SELECT DISTINCT "{column}" FROM {table_name} LIMIT {num_vals}'
+                )
                 res[column] = [d.text for d in unique_vals]
         except Exception as e:
-            return {f"Error ({str(e)}) occurred while loading unique values for table {table_name}"}
+            return {
+                f"Error ({str(e)}) occurred while loading unique values for table {table_name}"
+            }
         return res
 
     def to_tool_list(self) -> List[FunctionTool]:

vectara_agentic/llm_utils.py

@@ -2,10 +2,10 @@
 Utilities for the Vectara agentic.
 """
 
-from typing import Tuple, Callable, Optional
+from typing import Tuple, Optional
 import os
 from functools import lru_cache
-import tiktoken
+import hashlib
 
 from llama_index.core.llms import LLM
 from llama_index.llms.openai import OpenAI
@@ -13,7 +13,7 @@ from llama_index.llms.anthropic import Anthropic
 
 # LLM provider imports are now lazy-loaded in get_llm() function
 
-from .types import LLMRole, AgentType, ModelProvider
+from .types import LLMRole, ModelProvider
 from .agent_config import AgentConfig
 
 provider_to_default_model_name = {
@@ -21,7 +21,6 @@ provider_to_default_model_name = {
     ModelProvider.ANTHROPIC: "claude-sonnet-4-20250514",
     ModelProvider.TOGETHER: "deepseek-ai/DeepSeek-V3",
     ModelProvider.GROQ: "deepseek-r1-distill-llama-70b",
-    ModelProvider.FIREWORKS: "accounts/fireworks/models/firefunction-v2",
     ModelProvider.BEDROCK: "us.anthropic.claude-sonnet-4-20250514-v1:0",
     ModelProvider.COHERE: "command-a-03-2025",
     ModelProvider.GEMINI: "models/gemini-2.5-flash",
@@ -29,6 +28,30 @@ provider_to_default_model_name = {
 
 DEFAULT_MODEL_PROVIDER = ModelProvider.OPENAI
 
+# Manual cache for LLM instances to handle mutable AgentConfig objects
+_llm_cache = {}
+
+
+def _create_llm_cache_key(role: LLMRole, config: Optional[AgentConfig] = None) -> str:
+    """Create a hash-based cache key for LLM instances."""
+    if config is None:
+        config = AgentConfig()
+
+    # Extract only the relevant config parameters for the cache key
+    cache_data = {
+        "role": role.value,
+        "main_llm_provider": config.main_llm_provider.value,
+        "main_llm_model_name": config.main_llm_model_name,
+        "tool_llm_provider": config.tool_llm_provider.value,
+        "tool_llm_model_name": config.tool_llm_model_name,
+        "private_llm_api_base": config.private_llm_api_base,
+        "private_llm_api_key": config.private_llm_api_key,
+    }
+
+    # Create a stable hash from the cache data
+    cache_str = str(sorted(cache_data.items()))
+    return hashlib.md5(cache_str.encode()).hexdigest()
+
 
 @lru_cache(maxsize=None)
 def _get_llm_params_for_role(
@@ -54,42 +77,20 @@ def _get_llm_params_for_role(
             model_provider
         )
 
-    # If the agent type is OpenAI, check that the main LLM provider is also OpenAI.
-    if role == LLMRole.MAIN and config.agent_type == AgentType.OPENAI:
-        if model_provider != ModelProvider.OPENAI:
-            raise ValueError(
-                "OpenAI agent requested but main model provider is not OpenAI."
-            )
-
     return model_provider, model_name
 
 
-@lru_cache(maxsize=None)
-def get_tokenizer_for_model(
-    role: LLMRole, config: Optional[AgentConfig] = None
-) -> Optional[Callable]:
-    """
-    Get the tokenizer for the specified model, as determined by the role & config.
-    """
-    model_name = "Unknown model"
-    try:
-        model_provider, model_name = _get_llm_params_for_role(role, config)
-        if model_provider == ModelProvider.OPENAI:
-            return tiktoken.encoding_for_model("gpt-4o").encode
-        if model_provider == ModelProvider.ANTHROPIC:
-            return Anthropic().tokenizer
-    except Exception:
-        print(f"Error getting tokenizer for model {model_name}, ignoring")
-        return None
-    return None
-
-
-@lru_cache(maxsize=None)
 def get_llm(role: LLMRole, config: Optional[AgentConfig] = None) -> LLM:
     """
     Get the LLM for the specified role, using the provided config
     or a default if none is provided.
+
+    Uses a cache based on configuration parameters to avoid repeated LLM instantiation.
     """
+    # Check cache first
+    cache_key = _create_llm_cache_key(role, config)
+    if cache_key in _llm_cache:
+        return _llm_cache[cache_key]
     model_provider, model_name = _get_llm_params_for_role(role, config)
     max_tokens = (
         16384
@@ -107,7 +108,7 @@ def get_llm(role: LLMRole, config: Optional[AgentConfig] = None) -> LLM:
             model=model_name,
             temperature=0,
             is_function_calling_model=True,
-            strict=True,
+            strict=False,
             max_tokens=max_tokens,
             pydantic_program_mode="openai",
         )
@@ -128,7 +129,6 @@ def get_llm(role: LLMRole, config: Optional[AgentConfig] = None) -> LLM:
             model=model_name,
             temperature=0,
             is_function_calling_model=True,
-            allow_parallel_tool_calls=True,
             max_tokens=max_tokens,
         )
     elif model_provider == ModelProvider.TOGETHER:
@@ -157,14 +157,6 @@ def get_llm(role: LLMRole, config: Optional[AgentConfig] = None) -> LLM:
             is_function_calling_model=True,
             max_tokens=max_tokens,
         )
-    elif model_provider == ModelProvider.FIREWORKS:
-        try:
-            from llama_index.llms.fireworks import Fireworks
-        except ImportError as e:
-            raise ImportError(
-                "fireworks not available. Install with: pip install llama-index-llms-fireworks"
-            ) from e
-        llm = Fireworks(model=model_name, temperature=0, max_tokens=max_tokens)
     elif model_provider == ModelProvider.BEDROCK:
         try:
             from llama_index.llms.bedrock_converse import BedrockConverse
@@ -197,6 +189,10 @@ def get_llm(role: LLMRole, config: Optional[AgentConfig] = None) -> LLM:
             raise ImportError(
                 "openai_like not available. Install with: pip install llama-index-llms-openai-like"
             ) from e
+        if not config or not config.private_llm_api_base or not config.private_llm_api_key:
+            raise ValueError(
+                "Private LLM requires both private_llm_api_base and private_llm_api_key to be set in AgentConfig."
+            )
         llm = OpenAILike(
             model=model_name,
             temperature=0,
@@ -209,4 +205,7 @@ def get_llm(role: LLMRole, config: Optional[AgentConfig] = None) -> LLM:
 
     else:
         raise ValueError(f"Unknown LLM provider: {model_provider}")
+
+    # Cache the created LLM instance
+    _llm_cache[cache_key] = llm
     return llm

vectara_agentic/sub_query_workflow.py

@@ -5,6 +5,8 @@ that takes a user question and a list of tools, and outputs a list of sub-questi
 
 import re
 import json
+import logging
+
 from pydantic import BaseModel, Field
 
 from llama_index.core.workflow import (
@@ -70,7 +72,6 @@ class SubQuestionQueryWorkflow(Workflow):
 
         query = ev.inputs.query
         await ctx.set("original_query", query)
-        print(f"Query is {query}")
 
         required_attrs = ["agent", "llm", "tools"]
         for attr in required_attrs:
@@ -114,9 +115,6 @@ class SubQuestionQueryWorkflow(Workflow):
             """,
         )
 
-        if await ctx.get("verbose"):
-            print(f"Sub-questions are {response}")
-
         response_str = str(response)
         if not response_str:
             raise ValueError(
@@ -139,7 +137,6 @@ class SubQuestionQueryWorkflow(Workflow):
         if not sub_questions:
             # If the LLM returns an empty list, we need to handle it gracefully
             # We use the original query as a single question fallback
-            print("LLM returned empty sub-questions list")
             sub_questions = [original_query]
 
         await ctx.set("sub_question_count", len(sub_questions))
@@ -154,7 +151,7 @@ class SubQuestionQueryWorkflow(Workflow):
         Given a sub-question, return the answer to the sub-question, using the agent.
         """
         if await ctx.get("verbose"):
-            print(f"Sub-question is {ev.question}")
+            logging.info(f"Sub-question is {ev.question}")
         agent = await ctx.get("agent")
         question = ev.question
         response = await agent.achat(question)
@@ -188,14 +185,13 @@ class SubQuestionQueryWorkflow(Workflow):
             {answers}
         """
         if await ctx.get("verbose"):
-            print(f"Final prompt is {prompt}")
+            logging.info(f"Final prompt is {prompt}")
 
         llm = await ctx.get("llm")
         response = llm.complete(prompt)
 
         if await ctx.get("verbose"):
-            print("Final response is", response)
-
+            logging.info(f"Final response is {response}")
         return StopEvent(result=self.OutputsModel(response=str(response)))
 
 
@@ -274,8 +270,7 @@ class SequentialSubQuestionsWorkflow(Workflow):
 
         original_query = await ctx.get("original_query")
         if ev.verbose:
-            print(f"Query is {original_query}")
-
+            logging.info(f"Query is {original_query}")
         llm = await ctx.get("llm")
         response = llm.complete(
             f"""
@@ -326,7 +321,7 @@ class SequentialSubQuestionsWorkflow(Workflow):
 
         await ctx.set("sub_questions", sub_questions)
         if await ctx.get("verbose"):
-            print(f"Sub-questions are {sub_questions}")
+            logging.info(f"Sub-questions are {sub_questions}")
 
         return self.QueryEvent(question=sub_questions[0], prev_answer="", num=0)
 
@@ -338,7 +333,7 @@ class SequentialSubQuestionsWorkflow(Workflow):
         Given a sub-question, return the answer to the sub-question, using the agent.
         """
         if await ctx.get("verbose"):
-            print(f"Sub-question is {ev.question}")
+            logging.info(f"Sub-question is {ev.question}")
         agent = await ctx.get("agent")
         sub_questions = await ctx.get("sub_questions")
         question = ev.question
@@ -353,7 +348,7 @@ class SequentialSubQuestionsWorkflow(Workflow):
             response = await agent.achat(question)
         answer = response.response
         if await ctx.get("verbose"):
-            print(f"Answer is {answer}")
+            logging.info(f"Answer is {answer}")
 
         if ev.num + 1 < len(sub_questions):
             await ctx.set("qna", await ctx.get("qna", []) + [(question, answer)])