vectara-agentic 0.1.22__py3-none-any.whl → 0.1.24__py3-none-any.whl

tests/test_agent.py

@@ -2,7 +2,8 @@ import unittest
 from datetime import date
 
 from vectara_agentic.agent import _get_prompt, Agent, AgentType, FunctionTool
-
+from vectara_agentic.agent_config import AgentConfig
+from vectara_agentic.types import ModelProvider, ObserverType
 
 class TestAgentPackage(unittest.TestCase):
     def test_get_prompt(self):
@@ -43,6 +44,48 @@ class TestAgentPackage(unittest.TestCase):
             "50",
         )
 
+    def test_agent_config(self):
+        def mult(x, y):
+            return x * y
+
+        tools = [
+            FunctionTool.from_defaults(
+                fn=mult, name="mult", description="Multiplication functions"
+            )
+        ]
+        topic = "AI topic"
+        instructions = "Always do as your father tells you, if your mother agrees!"
+        config = AgentConfig(
+            agent_type=AgentType.REACT,
+            main_llm_provider=ModelProvider.ANTHROPIC,
+            main_llm_model_name="claude-3-5-sonnet-20241022",
+            tool_llm_provider=ModelProvider.TOGETHER,
+            tool_llm_model_name="meta-llama/Llama-3.3-70B-Instruct-Turbo",
+            observer=ObserverType.ARIZE_PHOENIX
+        )
+
+        agent = Agent(
+            tools=tools,
+            topic=topic,
+            custom_instructions=instructions,
+            agent_config=config
+        )
+        self.assertEqual(agent.tools, tools)
+        self.assertEqual(agent._topic, topic)
+        self.assertEqual(agent._custom_instructions, instructions)
+        self.assertEqual(agent.agent_type, AgentType.REACT)
+        self.assertEqual(agent.agent_config.observer, ObserverType.ARIZE_PHOENIX)
+        self.assertEqual(agent.agent_config.main_llm_provider, ModelProvider.ANTHROPIC)
+        self.assertEqual(agent.agent_config.tool_llm_provider, ModelProvider.TOGETHER)
+
+        # To run this test, you must have OPENAI_API_KEY in your environment
+        self.assertEqual(
+            agent.chat(
+                "What is 5 times 10. Only give the answer, nothing else"
+            ).replace("$", "\\$"),
+            "50",
+        )
+
     def test_from_corpus(self):
         agent = Agent.from_corpus(
             tool_name="RAG Tool",

tests/test_tools.py

@@ -32,7 +32,7 @@ class TestToolsPackage(unittest.TestCase):
 
         self.assertIsInstance(query_tool, VectaraTool)
         self.assertIsInstance(query_tool, FunctionTool)
-        self.assertEqual(query_tool.tool_type, ToolType.QUERY)
+        self.assertEqual(query_tool.metadata.tool_type, ToolType.QUERY)
 
     def test_tool_factory(self):
         def mult(x, y):
@@ -42,7 +42,7 @@ class TestToolsPackage(unittest.TestCase):
         other_tool = tools_factory.create_tool(mult)
         self.assertIsInstance(other_tool, VectaraTool)
         self.assertIsInstance(other_tool, FunctionTool)
-        self.assertEqual(other_tool.tool_type, ToolType.QUERY)
+        self.assertEqual(other_tool.metadata.tool_type, ToolType.QUERY)
 
     def test_llama_index_tools(self):
         tools_factory = ToolsFactory()
@@ -56,7 +56,7 @@ class TestToolsPackage(unittest.TestCase):
 
         self.assertIsInstance(arxiv_tool, VectaraTool)
         self.assertIsInstance(arxiv_tool, FunctionTool)
-        self.assertEqual(arxiv_tool.tool_type, ToolType.QUERY)
+        self.assertEqual(arxiv_tool.metadata.tool_type, ToolType.QUERY)
 
     def test_public_repo(self):
         vectara_customer_id = "1366999410"

vectara_agentic/__init__.py

@@ -2,22 +2,8 @@
 vectara_agentic package.
 """
 
-# Define the package version
-__version__ = "0.1.22"
+from .agent import Agent
+from .tools import VectaraToolFactory, VectaraTool
 
-# Import classes and functions from modules
-# from .module1 import Class1, function1
-# from .module2 import Class2, function2
-
-
-# Any initialization code
-def initialize_package():
-    """print a message when the package is initialized."""
-    print(f"Initializing vectara-agentic version {__version__}...")
-
-
-initialize_package()
-
-
-# Define the __all__ variable
-# __all__ = ['Class1', 'function1', 'Class2', 'function2']
+# Define the __all__ variable for wildcard imports
+__all__ = ['Agent', 'VectaraToolFactory', 'VectaraTool']

vectara_agentic/_observability.py

@@ -6,16 +6,16 @@ import json
 from typing import Optional, Union
 import pandas as pd
 from .types import ObserverType
+from .agent_config import AgentConfig
 
-def setup_observer() -> bool:
+def setup_observer(config: AgentConfig) -> bool:
     '''
     Setup the observer.
     '''
     import phoenix as px
     from openinference.instrumentation.llama_index import LlamaIndexInstrumentor
     from phoenix.otel import register
-    observer = ObserverType(os.getenv("VECTARA_AGENTIC_OBSERVER_TYPE", "NO_OBSERVER"))
-    if observer == ObserverType.ARIZE_PHOENIX:
+    if config.observer == ObserverType.ARIZE_PHOENIX:
         phoenix_endpoint = os.getenv("PHOENIX_ENDPOINT", None)
         if not phoenix_endpoint:
             px.launch_app()

vectara_agentic/_prompts.py

@@ -31,7 +31,8 @@ GENERAL_INSTRUCTIONS = """
   - Use the x_load_unique_values tool to understand the unique values in each column.
     Sometimes the user may ask for a specific column value, but the actual value in the table may be different, and you will need to use the correct value.
   - Use the x_load_sample_data tool to understand the column names, and typical values in each column.
-- For tool arguments that support conditional logic (such as year='>2022'), use only one of these operators: [">=", "<=", "!=", ">", "<", "="].
+- For tool arguments that support conditional logic (such as year='>2022'), use one of these operators: [">=", "<=", "!=", ">", "<", "="],
+  or a range operator, with inclusive or exclusive brackets (such as '[2021,2022]' or '[2021,2023)').
 - Do not mention table names or database names in your response.
 """
 

vectara_agentic/_version.py

@@ -0,0 +1,4 @@
+"""
+Define the version of the package.
+"""
+__version__ = "0.1.24"

vectara_agentic/agent.py

@@ -31,6 +31,7 @@ from ._prompts import REACT_PROMPT_TEMPLATE, GENERAL_PROMPT_TEMPLATE, GENERAL_IN
 from ._callback import AgentCallbackHandler
 from ._observability import setup_observer, eval_fcs
 from .tools import VectaraToolFactory, VectaraTool
+from .agent_config import AgentConfig
 
 logger = logging.getLogger("opentelemetry.exporter.otlp.proto.http.trace_exporter")
 logger.setLevel(logging.CRITICAL)
@@ -91,7 +92,7 @@ class Agent:
         verbose: bool = True,
         update_func: Optional[Callable[[AgentStatusType, str], None]] = None,
         agent_progress_callback: Optional[Callable[[AgentStatusType, str], None]] = None,
-        agent_type: AgentType = None,
+        agent_config: Optional[AgentConfig] = None,
     ) -> None:
         """
         Initialize the agent with the specified type, tools, topic, and system message.
@@ -104,11 +105,13 @@ class Agent:
             verbose (bool, optional): Whether the agent should print its steps. Defaults to True.
             agent_progress_callback (Callable): A callback function the code calls on any agent updates.
                 update_func (Callable): old name for agent_progress_callback. Will be deprecated in future.
-            agent_type (AgentType, optional): The type of agent to be used. Defaults to None.
+            agent_config (AgentConfig, optional): The configuration of the agent.
+                Defaults to AgentConfig(), which reads from environment variables.
         """
-        self.agent_type = agent_type or AgentType(os.getenv("VECTARA_AGENTIC_AGENT_TYPE", "OPENAI"))
+        self.agent_config = agent_config or AgentConfig()
+        self.agent_type = self.agent_config.agent_type
         self.tools = tools
-        self.llm = get_llm(LLMRole.MAIN)
+        self.llm = get_llm(LLMRole.MAIN, config=self.agent_config)
         self._custom_instructions = custom_instructions
         self._topic = topic
         self.agent_progress_callback = agent_progress_callback if agent_progress_callback else update_func
@@ -181,7 +184,7 @@ class Agent:
             raise ValueError(f"Unknown agent type: {self.agent_type}")
 
         try:
-            self.observability_enabled = setup_observer()
+            self.observability_enabled = setup_observer(self.agent_config)
         except Exception as e:
             print(f"Failed to set up observer ({e}), ignoring")
             self.observability_enabled = False
@@ -252,7 +255,7 @@ class Agent:
         verbose: bool = True,
         update_func: Optional[Callable[[AgentStatusType, str], None]] = None,
         agent_progress_callback: Optional[Callable[[AgentStatusType, str], None]] = None,
-        agent_type: AgentType = None,
+        agent_config: AgentConfig = AgentConfig(),
     ) -> "Agent":
         """
         Create an agent from tools, agent type, and language model.
@@ -265,7 +268,7 @@ class Agent:
             verbose (bool, optional): Whether the agent should print its steps. Defaults to True.
             agent_progress_callback (Callable): A callback function the code calls on any agent updates.
                 update_func (Callable): old name for agent_progress_callback. Will be deprecated in future.
-            agent_type (AgentType, optional): The type of agent to be used. Defaults to None.
+            agent_config (AgentConfig, optional): The configuration of the agent.
 
         Returns:
             Agent: An instance of the Agent class.
@@ -273,7 +276,7 @@ class Agent:
         return cls(
             tools=tools, topic=topic, custom_instructions=custom_instructions,
             verbose=verbose, agent_progress_callback=agent_progress_callback,
-            update_func=update_func, agent_type=agent_type
+            update_func=update_func, agent_config=agent_config
         )
 
     @classmethod
@@ -378,7 +381,10 @@ class Agent:
         print(f"Topic = {self._topic}")
         print("Tools:")
         for tool in self.tools:
-            print(f"- {tool.metadata.name}")
+            if hasattr(tool, 'metadata'):
+                print(f"- {tool.metadata.name}")
+            else:
+                print("- tool without metadata")
         print(f"Agent LLM = {get_llm(LLMRole.MAIN).metadata.model_name}")
         print(f"Tool LLM = {get_llm(LLMRole.TOOL).metadata.model_name}")
 
@@ -449,7 +455,7 @@ class Agent:
         for tool in self.tools:
             # Serialize each tool's metadata, function, and dynamic model schema (QueryArgs)
             tool_dict = {
-                "tool_type": tool.tool_type.value,
+                "tool_type": tool.metadata.tool_type.value,
                 "name": tool.metadata.name,
                 "description": tool.metadata.description,
                 "fn": dill.dumps(tool.fn).decode("latin-1") if tool.fn else None,  # Serialize fn
@@ -469,12 +475,13 @@ class Agent:
             "topic": self._topic,
             "custom_instructions": self._custom_instructions,
             "verbose": self.verbose,
+            "agent_config": self.agent_config.to_dict(),
         }
 
     @classmethod
     def from_dict(cls, data: Dict[str, Any]) -> "Agent":
         """Create an Agent instance from a dictionary."""
-        agent_type = AgentType(data["agent_type"])
+        agent_config = AgentConfig.from_dict(data["agent_config"])
         tools = []
 
         json_type_to_python = {
@@ -523,7 +530,7 @@ class Agent:
 
         agent = cls(
             tools=tools,
-            agent_type=agent_type,
+            agent_config=agent_config,
             topic=data["topic"],
             custom_instructions=data["custom_instructions"],
             verbose=data["verbose"],

vectara_agentic/agent_config.py

@@ -0,0 +1,86 @@
+"""
+Define the AgentConfig dataclass for the Vectara Agentic utilities.
+"""
+
+import os
+from dataclasses import dataclass, field
+from .types import ModelProvider, AgentType, ObserverType
+
+@dataclass(eq=True, frozen=True)
+class AgentConfig:
+    """
+    Centralized configuration for the Vectara Agentic utilities.
+
+    Each field can default to either a hard-coded value or an environment
+    variable. For example, if you have environment variables you want to
+    fall back on, you can default to them here.
+    """
+
+    # Agent type
+    agent_type: AgentType = field(
+        default_factory=lambda: AgentType(
+            os.getenv("VECTARA_AGENTIC_AGENT_TYPE", AgentType.OPENAI.value)
+        )
+    )
+
+    # Main LLM provider & model name
+    main_llm_provider: ModelProvider = field(
+        default_factory=lambda: ModelProvider(
+            os.getenv("VECTARA_AGENTIC_MAIN_LLM_PROVIDER", ModelProvider.OPENAI.value)
+        )
+    )
+
+    main_llm_model_name: str = field(
+        default_factory=lambda: os.getenv("VECTARA_AGENTIC_MAIN_LLM_MODEL_NAME", "")
+    )
+
+    # Tool LLM provider & model name
+    tool_llm_provider: ModelProvider = field(
+        default_factory=lambda: ModelProvider(
+            os.getenv("VECTARA_AGENTIC_TOOL_LLM_PROVIDER", ModelProvider.OPENAI.value)
+        )
+    )
+    tool_llm_model_name: str = field(
+        default_factory=lambda: os.getenv("VECTARA_AGENTIC_TOOL_LLM_MODEL_NAME", "")
+    )
+
+    # Observer
+    observer: ObserverType = field(
+        default_factory=lambda: ObserverType(
+            os.getenv("VECTARA_AGENTIC_OBSERVER_TYPE", "NO_OBSERVER")
+        )
+    )
+
+    # Endpoint API key
+    endpoint_api_key: str = field(
+        default_factory=lambda: os.getenv("VECTARA_AGENTIC_API_KEY", "dev-api-key")
+    )
+
+    def to_dict(self) -> dict:
+        """
+        Convert the AgentConfig to a dictionary.
+        """
+        return {
+            "agent_type": self.agent_type.value,
+            "main_llm_provider": self.main_llm_provider.value,
+            "main_llm_model_name": self.main_llm_model_name,
+            "tool_llm_provider": self.tool_llm_provider.value,
+            "tool_llm_model_name": self.tool_llm_model_name,
+            "observer": self.observer.value,
+            "endpoint_api_key": self.endpoint_api_key
+        }
+
+    @classmethod
+    def from_dict(cls, config_dict: dict) -> "AgentConfig":
+        """
+        Create an AgentConfig from a dictionary.
+        """
+        return cls(
+            agent_type=AgentType(config_dict["agent_type"]),
+            main_llm_provider=ModelProvider(config_dict["main_llm_provider"]),
+            main_llm_model_name=config_dict["main_llm_model_name"],
+            tool_llm_provider=ModelProvider(config_dict["tool_llm_provider"]),
+            tool_llm_model_name=config_dict["tool_llm_model_name"],
+            observer=ObserverType(config_dict["observer"]),
+            endpoint_api_key=config_dict["endpoint_api_key"]
+        )

vectara_agentic/agent_endpoint.py

@@ -1,7 +1,6 @@
 """
 This module contains functions to start the agent behind an API endpoint.
 """
-import os
 import logging
 from fastapi import FastAPI, HTTPException, Depends
 from fastapi.security.api_key import APIKeyHeader
@@ -9,10 +8,9 @@ from pydantic import BaseModel
 import uvicorn
 
 from .agent import Agent
+from .agent_config import AgentConfig
 
-API_KEY_NAME = "X-API-Key"
-API_KEY = os.getenv("VECTARA_AGENTIC_API_KEY", "dev-api-key")
-api_key_header = APIKeyHeader(name=API_KEY_NAME)
+api_key_header = APIKeyHeader(name="X-API-Key")
 
 class ChatRequest(BaseModel):
     """
@@ -21,18 +19,19 @@ class ChatRequest(BaseModel):
     message: str
 
 
-def create_app(agent: Agent) -> FastAPI:
+def create_app(agent: Agent, config: AgentConfig) -> FastAPI:
     """
     Create a FastAPI application with a chat endpoint.
     """
     app = FastAPI()
     logger = logging.getLogger("uvicorn.error")
     logging.basicConfig(level=logging.INFO)
+    endpoint_api_key = config.endpoint_api_key
 
     @app.get("/chat", summary="Chat with the agent")
     async def chat(message: str, api_key: str = Depends(api_key_header)):
         logger.info(f"Received message: {message}")
-        if api_key != API_KEY:
+        if api_key != endpoint_api_key:
             logger.warning("Unauthorized access attempt")
             raise HTTPException(status_code=403, detail="Unauthorized")
 
@@ -59,5 +58,5 @@ def start_app(agent: Agent, host='0.0.0.0', port=8000):
         host (str, optional): The host address for the API. Defaults to '127.0.0.1'.
         port (int, optional): The port for the API. Defaults to 8000.
     """
-    app = create_app(agent)
+    app = create_app(agent, config=AgentConfig())
     uvicorn.run(app, host=host, port=port)

vectara_agentic/tools.py

@@ -9,6 +9,7 @@ import os
 
 from typing import Callable, List, Dict, Any, Optional, Type
 from pydantic import BaseModel, Field
+from pydantic_core import PydanticUndefined
 
 from llama_index.core.tools import FunctionTool
 from llama_index.core.tools.function_tool import AsyncCallable
@@ -227,8 +228,60 @@ class VectaraToolFactory:
                         f'Unrecognized prefix {prefix}. Please make sure to use either "doc" or "part" for the prefix.'
                     )
 
-                # Check if value contains a known comparison operator at the start
+                if value is PydanticUndefined:
+                    raise ValueError(
+                        f"Value of argument {key} is undefined, and this is invalid. "
+                        "Please form proper arguments and try again."
+                    )
+
+                # value of the arrgument
                 val_str = str(value).strip()
+
+                # Special handling for range operator
+                if val_str.startswith(("[", "(")) and val_str.endswith(("]", ")")):
+                    # Extract the boundary types
+                    start_inclusive = val_str.startswith("[")
+                    end_inclusive = val_str.endswith("]")
+
+                    # Remove the boundaries and strip whitespace
+                    val_str = val_str[1:-1].strip()
+
+                    if "," in val_str:
+                        val_str = val_str.split(",")
+                        if len(val_str) != 2:
+                            raise ValueError(
+                                f"Range operator requires two values for {key}: {value}"
+                            )
+
+                        # Validate both bounds as numeric or empty (for unbounded ranges)
+                        start_val, end_val = val_str[0].strip(), val_str[1].strip()
+                        if start_val and not (start_val.isdigit() or is_float(start_val)):
+                            raise ValueError(
+                                f"Range operator requires numeric operands for {key}: {value}"
+                            )
+                        if end_val and not (end_val.isdigit() or is_float(end_val)):
+                            raise ValueError(
+                                f"Range operator requires numeric operands for {key}: {value}"
+                            )
+
+                        # Build the SQL condition
+                        range_conditions = []
+                        if start_val:
+                            operator = ">=" if start_inclusive else ">"
+                            range_conditions.append(f"{prefix}.{key} {operator} {start_val}")
+                        if end_val:
+                            operator = "<=" if end_inclusive else "<"
+                            range_conditions.append(f"{prefix}.{key} {operator} {end_val}")
+
+                        # Join the range conditions with AND
+                        filter_parts.append('( ' + " AND ".join(range_conditions) + ' )')
+                        continue
+
+                    raise ValueError(
+                        f"Range operator requires two values for {key}: {value}"
+                    )
+
+                # Check if value contains a known comparison operator at the start
                 matched_operator = None
                 for op in comparison_operators:
                     if val_str.startswith(op):
@@ -251,12 +304,19 @@ class VectaraToolFactory:
                         # = and != operators can be numeric or string
                         if rhs.isdigit() or is_float(rhs):
                             filter_parts.append(f"{prefix}.{key}{matched_operator}{rhs}")
+                        elif rhs.lower() in ["true", "false"]:
+                            filter_parts.append(f"{prefix}.{key}{matched_operator}{rhs.lower()}")
                         else:
                             # For string operands, wrap them in quotes
                             filter_parts.append(f"{prefix}.{key}{matched_operator}'{rhs}'")
                 else:
                     if val_str.isdigit() or is_float(val_str):
                         filter_parts.append(f"{prefix}.{key}={val_str}")
+                    elif val_str.lower() in ["true", "false"]:
+                        # This is to handle boolean values.
+                        # This is not complete solution - the best solution would be to test if the field is boolean
+                        # That can be done after we move to APIv2
+                        filter_parts.append(f"{prefix}.{key}={val_str.lower()}")
                     else:
                         filter_parts.append(f"{prefix}.{key}='{val_str}'")
 
@@ -274,7 +334,15 @@ class VectaraToolFactory:
             kwargs = bound_args.arguments
 
             query = kwargs.pop("query")
-            filter_string = _build_filter_string(kwargs, tool_args_type)
+            try:
+                filter_string = _build_filter_string(kwargs, tool_args_type)
+            except ValueError as e:
+                return ToolOutput(
+                    tool_name=rag_function.__name__,
+                    content=str(e),
+                    raw_input={"args": args, "kwargs": kwargs},
+                    raw_output={"response": str(e)},
+                )
 
             vectara_query_engine = vectara.as_query_engine(
                 summary_enabled=True,

vectara_agentic/utils.py

@@ -2,7 +2,6 @@
 Utilities for the Vectara agentic.
 """
 
-import os
 from typing import Tuple, Callable, Optional
 from functools import lru_cache
 
@@ -13,6 +12,7 @@ from llama_index.llms.openai import OpenAI
 from llama_index.llms.anthropic import Anthropic
 
 from .types import LLMRole, AgentType, ModelProvider
+from .agent_config import AgentConfig
 
 provider_to_default_model_name = {
     ModelProvider.OPENAI: "gpt-4o",
@@ -27,44 +27,52 @@ provider_to_default_model_name = {
 DEFAULT_MODEL_PROVIDER = ModelProvider.OPENAI
 
 @lru_cache(maxsize=None)
-def _get_llm_params_for_role(role: LLMRole) -> Tuple[ModelProvider, str]:
-    """Get the model provider and model name for the specified role."""
+def _get_llm_params_for_role(
+    role: LLMRole,
+    config: Optional[AgentConfig] = None
+) -> Tuple[ModelProvider, str]:
+    """
+    Get the model provider and model name for the specified role.
+
+    If config is None, a new AgentConfig() is instantiated using environment defaults.
+    """
+    config = config or AgentConfig()  # fallback to default config
+
     if role == LLMRole.TOOL:
-        model_provider = ModelProvider(
-            os.getenv("VECTARA_AGENTIC_TOOL_LLM_PROVIDER", DEFAULT_MODEL_PROVIDER.value)
-        )
-        model_name = os.getenv(
-            "VECTARA_AGENTIC_TOOL_MODEL_NAME",
-            provider_to_default_model_name.get(model_provider),
+        model_provider = config.tool_llm_provider
+        # If the user hasn’t explicitly set a tool_llm_model_name,
+        # fallback to provider default from provider_to_default_model_name
+        model_name = (
+            config.tool_llm_model_name
+            or provider_to_default_model_name.get(model_provider)
         )
     else:
-        model_provider = ModelProvider(
-            os.getenv("VECTARA_AGENTIC_MAIN_LLM_PROVIDER", DEFAULT_MODEL_PROVIDER.value)
-        )
-        model_name = os.getenv(
-            "VECTARA_AGENTIC_MAIN_MODEL_NAME",
-            provider_to_default_model_name.get(model_provider),
+        model_provider = config.main_llm_provider
+        model_name = (
+            config.main_llm_model_name
+            or provider_to_default_model_name.get(model_provider)
         )
 
-    agent_type = AgentType(
-        os.getenv("VECTARA_AGENTIC_AGENT_TYPE", AgentType.OPENAI.value)
-    )
-    if (
-        role == LLMRole.MAIN
-        and agent_type == AgentType.OPENAI
-        and model_provider != ModelProvider.OPENAI
-    ):
-        raise ValueError(
-            "OpenAI agent requested but main model provider is not OpenAI."
-        )
+    # 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) -> Optional[Callable]:
-    """Get the tokenizer for the specified model."""
-    model_provider, model_name = _get_llm_params_for_role(role)
+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_provider, model_name = _get_llm_params_for_role(role, config)
     if model_provider == ModelProvider.OPENAI:
+        # This might raise an exception if the model_name is unknown to tiktoken
         return tiktoken.encoding_for_model(model_name).encode
     if model_provider == ModelProvider.ANTHROPIC:
         return Anthropic().tokenizer
@@ -72,10 +80,15 @@ def get_tokenizer_for_model(role: LLMRole) -> Optional[Callable]:
 
 
 @lru_cache(maxsize=None)
-def get_llm(role: LLMRole) -> LLM:
-    """Get the LLM for the specified role."""
-    model_provider, model_name = _get_llm_params_for_role(role)
-
+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.
+    """
+    model_provider, model_name = _get_llm_params_for_role(role, config)
     if model_provider == ModelProvider.OPENAI:
         llm = OpenAI(model=model_name, temperature=0, is_function_calling_model=True)
     elif model_provider == ModelProvider.ANTHROPIC:
@@ -97,7 +110,6 @@ def get_llm(role: LLMRole) -> LLM:
         llm = Cohere(model=model_name, temperature=0)
     else:
         raise ValueError(f"Unknown LLM provider: {model_provider}")
-
     return llm
 
 def is_float(value: str) -> bool:

{vectara_agentic-0.1.22.dist-info → vectara_agentic-0.1.24.dist-info}/METADATA

@@ -1,12 +1,12 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: vectara_agentic
-Version: 0.1.22
+Version: 0.1.24
 Summary: A Python package for creating AI Assistants and AI Agents with Vectara
 Home-page: https://github.com/vectara/py-vectara-agentic
 Author: Ofer Mendelevitch
 Author-email: ofer@vectara.com
 Project-URL: Documentation, https://vectara.github.io/vectara-agentic-docs/
-Keywords: LLM,NLP,RAG,Agentic-RAG
+Keywords: LLM,NLP,RAG,Agentic-RAG,AI assistant,AI Agent,Vectara
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: OS Independent
@@ -53,6 +53,17 @@ Requires-Dist: python-dotenv==1.0.1
 Requires-Dist: tiktoken==0.8.0
 Requires-Dist: dill>=0.3.7
 Requires-Dist: httpx==0.27.2
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: project-url
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 # <img src="https://raw.githubusercontent.com/vectara/py-vectara-agentic/main/.github/assets/Vectara-logo.png" alt="Vectara Logo" width="30" height="30" style="vertical-align: middle;"> vectara-agentic
 
@@ -128,10 +139,18 @@ vec_factory = VectaraToolFactory(
     vectara_corpus_id=os.environ['VECTARA_CORPUS_ID']
 )
 
+years = list(range(2020, 2024))
+tickers = {
+    "AAPL": "Apple Computer",
+    "GOOG": "Google",
+    "AMZN": "Amazon",
+    "SNOW": "Snowflake",
+}
+
 class QueryFinancialReportsArgs(BaseModel):
     query: str = Field(..., description="The user query.")
-    year: int = Field(..., description="The year. An integer between {min(years)} and {max(years)}.")
-    ticker: str = Field(..., description="The company ticker. Must be a valid ticket symbol from the list {tickers.keys()}.")
+    year: int | str = Field(..., description=f"The year this query relates to. An integer between {min(years)} and {max(years)} or a string specifying a condition on the year (example: '>2020').")
+    ticker: str = Field(..., description=f"The company ticker. Must be a valid ticket symbol from the list {tickers.keys()}.")
 
 query_financial_reports_tool = vec_factory.create_rag_tool(
     tool_name="query_financial_reports",
@@ -218,16 +237,19 @@ mult_tool = ToolsFactory().create_tool(mult_func)
 
 ## 🛠️ Configuration
 
-Configure `vectara-agentic` using environment variables:
-
+The main way to control the behavior of `vectara-agentic` is by passing an `AgentConfig` object to your `Agent` when creating it.
+This object will include the following items:
 - `VECTARA_AGENTIC_AGENT_TYPE`: valid values are `REACT`, `LLMCOMPILER`, `LATS` or `OPENAI` (default: `OPENAI`)
 - `VECTARA_AGENTIC_MAIN_LLM_PROVIDER`: valid values are `OPENAI`, `ANTHROPIC`, `TOGETHER`, `GROQ`, `COHERE`, `GEMINI` or `FIREWORKS` (default: `OPENAI`)
 - `VECTARA_AGENTIC_MAIN_MODEL_NAME`: agent model name (default depends on provider)
 - `VECTARA_AGENTIC_TOOL_LLM_PROVIDER`: tool LLM provider (default: `OPENAI`)
 - `VECTARA_AGENTIC_TOOL_MODEL_NAME`: tool model name (default depends on provider)
 - `VECTARA_AGENTIC_OBSERVER_TYPE`: valid values are `ARIZE_PHOENIX` or `NONE` (default: `NONE`)
+- `VECTARA_AGENTIC_API_KEY`: a secret key if using the API endpoint option (defaults to `dev-api-key`)
 
-When creating a VectaraToolFactory, you can pass in a `vectara_api_key`, `vectara_customer_id`, and `vectara_corpus_id` to the factory. If not passed in, it will be taken from the environment variables. Note that `VECTARA_CORPUS_ID` can be a single ID or a comma-separated list of IDs (if you want to query multiple corpora).
+If any of these are not provided, `AgentConfig` first tries to read the values from the OS environment.
+
+When creating a `VectaraToolFactory`, you can pass in a `vectara_api_key`, `vectara_customer_id`, and `vectara_corpus_id` to the factory. If not passed in, it will be taken from the environment variables (`VECTARA_API_KEY`, `VECTARA_CUSTOMER_ID` and `VECTARA_CORPUS_ID`). Note that `VECTARA_CORPUS_ID` can be a single ID or a comma-separated list of IDs (if you want to query multiple corpora).
 
 ## ℹ️ Additional Information
 
@@ -252,7 +274,8 @@ The `Agent` class supports serialization. Use the `dumps()` to serialize and `lo
 ###  Observability
 
 vectara-agentic supports observability via the existing integration of LlamaIndex and Arize Phoenix.
-First, set `os["VECTARA_AGENTIC_OBSERVER_TYPE"] = "ARIZE_PHOENIX"`.
+First, set `VECTARA_AGENTIC_OBSERVER_TYPE` to `ARIZE_PHOENIX` in `AgentConfig` (or env variable).
+
 Then you can use Arize Phoenix in three ways: 
 1. **Locally**. 
    1. If you have a local phoenix server that you've run using e.g. `python -m phoenix.server.main serve`, vectara-agentic will send all traces to it.
@@ -260,7 +283,7 @@ Then you can use Arize Phoenix in three ways:
    3. In both cases, traces will be sent to the local instance, and you can see the dashboard at `http://localhost:6006`
 2. **Hosted Instance**. In this case the traces are sent to the Phoenix instances hosted on Arize.
    1. Go to `https://app.phoenix.arize.com`, setup an account if you don't have one.
-   2. create an API key and put it in the `PHOENIX_API_KEY` variable. This variable indicates you want to use the hosted version.
+   2. create an API key and put it in the `PHOENIX_API_KEY` environment variable - this indicates you want to use the hosted version.
    3. To view the traces go to `https://app.phoenix.arize.com`.
 
 Now when you run your agent, all call traces are sent to Phoenix and recorded. 

vectara_agentic-0.1.24.dist-info/RECORD

@@ -0,0 +1,21 @@
+tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/test_agent.py,sha256=8LQlny0rIuVa13LGtebG0vatES6Ln7gmenbSwX-ctrY,4260
+tests/test_tools.py,sha256=2ofZYz3Q-YMSxjpiEg1VNUlA9gMjvNAcJAO2Ucd0eVE,2969
+vectara_agentic/__init__.py,sha256=FUWwh37ia9AduK4YDo_TCD52A09ocbYo49oYyBJtyqY,219
+vectara_agentic/_callback.py,sha256=OBiHk_OJZTS3iKz_LigfEjnl_p5V90XYsQC0vEYVSPo,8782
+vectara_agentic/_observability.py,sha256=HeQYJIkqPLW3EWHiXHatkaJzo08IQGESKujdeWTuRgk,3805
+vectara_agentic/_prompts.py,sha256=ITHWQQ4oSmRhqBwRcheYC_nMdZZielUOjfVIbDYi9rw,6257
+vectara_agentic/_version.py,sha256=3P-p27Ccx3RQ_PJQDAu-lIwPrPQ8S780FnRmeItjqNg,66
+vectara_agentic/agent.py,sha256=35dc7RBYevvX9XGz1WoPRQL6N8NnWxL_Eac56e1JpFo,22427
+vectara_agentic/agent_config.py,sha256=8q_eRPURAZYHUXu_rxD2eO1XHC9jNGe_d9ytPgXbS7g,2949
+vectara_agentic/agent_endpoint.py,sha256=QIMejCLlpW2qzXxeDAxv3anF46XMDdVMdKGWhJh3azY,1996
+vectara_agentic/db_tools.py,sha256=kCEENzmnorm8i-k4Kpd4KLJt1QWh_ZlAyX1aG-tzET0,3619
+vectara_agentic/tools.py,sha256=Qhql8IA_CGvsZ3ErOFQH2y-sxxHXvL3GUDH6shgxmzQ,28262
+vectara_agentic/tools_catalog.py,sha256=5NlJypdu0IKa7mODxVOwo05lw3PqQJtSl_ZOsUDH_TA,3986
+vectara_agentic/types.py,sha256=siRh9VmFt3jhTu4uJzYpvNlLi60lyIH5_xqYHKpB24Q,1149
+vectara_agentic/utils.py,sha256=-hnILxUAAtcFRlupeNEVBwHpm-EMF98iLV1Z_hjVrNA,4460
+vectara_agentic-0.1.24.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+vectara_agentic-0.1.24.dist-info/METADATA,sha256=VtSVDzA0zHVWq5C8fNqjATQCOpF_zXIAsWiPYd2_Y5E,15379
+vectara_agentic-0.1.24.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+vectara_agentic-0.1.24.dist-info/top_level.txt,sha256=Y7TQTFdOYGYodQRltUGRieZKIYuzeZj2kHqAUpfCUfg,22
+vectara_agentic-0.1.24.dist-info/RECORD,,

{vectara_agentic-0.1.22.dist-info → vectara_agentic-0.1.24.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.6.0)
+Generator: setuptools (75.8.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

vectara_agentic-0.1.22.dist-info/RECORD

@@ -1,19 +0,0 @@
-tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/test_agent.py,sha256=aQYYr_8hKlFiDgyI5Dd39TG5vkmDJe7F_nIzMTCLsTQ,2517
-tests/test_tools.py,sha256=hDAlXkWKuXHnAjeQwMuTLTwNdRsM-xR7muBzFkZRefw,2942
-vectara_agentic/__init__.py,sha256=X9K53dm3OLnIwIXZCiX2eQVCF5ou0jypGtFpTfrZYIs,508
-vectara_agentic/_callback.py,sha256=OBiHk_OJZTS3iKz_LigfEjnl_p5V90XYsQC0vEYVSPo,8782
-vectara_agentic/_observability.py,sha256=v0xxTk8KI8nVK2rpyGqOVhyva9ymqOmZK5brKqFOwMM,3828
-vectara_agentic/_prompts.py,sha256=N656x-bfy9I5j2Lw51gpaGq_8R6zpPelPQ2-KWHHpTk,6160
-vectara_agentic/agent.py,sha256=Vr8R4sR_ZxJfGI94Jjze4r_rCCWYNvJ9UqsfjlAReWM,22045
-vectara_agentic/agent_endpoint.py,sha256=I3zTEezbAiNeW5I41r0NjIaR8Ucn4oe1XVcALekakaA,1959
-vectara_agentic/db_tools.py,sha256=kCEENzmnorm8i-k4Kpd4KLJt1QWh_ZlAyX1aG-tzET0,3619
-vectara_agentic/tools.py,sha256=OZ0qLtwS60J8XdVvuRDm21QBpLpEudVl659P37k8fCI,24798
-vectara_agentic/tools_catalog.py,sha256=5NlJypdu0IKa7mODxVOwo05lw3PqQJtSl_ZOsUDH_TA,3986
-vectara_agentic/types.py,sha256=siRh9VmFt3jhTu4uJzYpvNlLi60lyIH5_xqYHKpB24Q,1149
-vectara_agentic/utils.py,sha256=XzSo5tKSsQpgd6Kx3q-XREohbyIe7-UqlpUW-9y1KeQ,3998
-vectara_agentic-0.1.22.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-vectara_agentic-0.1.22.dist-info/METADATA,sha256=Jrw5HeZ2nyTeAX6cf69qmmpPUo2bArUNpA2WB_gqndo,14441
-vectara_agentic-0.1.22.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-vectara_agentic-0.1.22.dist-info/top_level.txt,sha256=Y7TQTFdOYGYodQRltUGRieZKIYuzeZj2kHqAUpfCUfg,22
-vectara_agentic-0.1.22.dist-info/RECORD,,