vectara-agentic 0.2.13__py3-none-any.whl → 0.2.14__py3-none-any.whl

tests/test_groq.py

@@ -0,0 +1,120 @@
+import unittest
+
+from pydantic import Field, BaseModel
+
+from vectara_agentic.agent import Agent, AgentType
+from vectara_agentic.agent_config import AgentConfig
+from vectara_agentic.tools import VectaraToolFactory
+from vectara_agentic.types import ModelProvider
+
+
+import nest_asyncio
+nest_asyncio.apply()
+
+tickers = {
+    "C": "Citigroup",
+    "COF": "Capital One",
+    "JPM": "JPMorgan Chase",
+    "AAPL": "Apple Computer",
+    "GOOG": "Google",
+    "AMZN": "Amazon",
+    "SNOW": "Snowflake",
+    "TEAM": "Atlassian",
+    "TSLA": "Tesla",
+    "NVDA": "Nvidia",
+    "MSFT": "Microsoft",
+    "AMD": "Advanced Micro Devices",
+    "INTC": "Intel",
+    "NFLX": "Netflix",
+    "STT": "State Street",
+    "BK": "Bank of New York Mellon",
+}
+years = list(range(2015, 2025))
+
+
+def mult(x: float, y: float) -> float:
+    "Multiply two numbers"
+    return x * y
+
+
+def get_company_info() -> list[str]:
+    """
+    Returns a dictionary of companies you can query about. Always check this before using any other tool.
+    The output is a dictionary of valid ticker symbols mapped to company names.
+    You can use this to identify the companies you can query about, and their ticker information.
+    """
+    return tickers
+
+
+def get_valid_years() -> list[str]:
+    """
+    Returns a list of the years for which financial reports are available.
+    Always check this before using any other tool.
+    """
+    return years
+
+
+config_gemini = AgentConfig(
+    agent_type=AgentType.FUNCTION_CALLING,
+    main_llm_provider=ModelProvider.GEMINI,
+    tool_llm_provider=ModelProvider.GEMINI,
+)
+
+
+fc_config_groq = AgentConfig(
+    agent_type=AgentType.FUNCTION_CALLING,
+    main_llm_provider=ModelProvider.GROQ,
+    tool_llm_provider=ModelProvider.GROQ,
+)
+
+
+class TestGROQ(unittest.TestCase):
+
+    def test_tool_with_many_arguments(self):
+
+        vectara_corpus_key = "vectara-docs_1"
+        vectara_api_key = "zqt_UXrBcnI2UXINZkrv4g1tQPhzj02vfdtqYJIDiA"
+        vec_factory = VectaraToolFactory(vectara_corpus_key, vectara_api_key)
+
+        class QueryToolArgs(BaseModel):
+            arg1: str = Field(description="the first argument", examples=["val1"])
+            arg2: str = Field(description="the second argument", examples=["val2"])
+            arg3: str = Field(description="the third argument", examples=["val3"])
+            arg4: str = Field(description="the fourth argument", examples=["val4"])
+            arg5: str = Field(description="the fifth argument", examples=["val5"])
+            arg6: str = Field(description="the sixth argument", examples=["val6"])
+            arg7: str = Field(description="the seventh argument", examples=["val7"])
+            arg8: str = Field(description="the eighth argument", examples=["val8"])
+            arg9: str = Field(description="the ninth argument", examples=["val9"])
+            arg10: str = Field(description="the tenth argument", examples=["val10"])
+            arg11: str = Field(description="the eleventh argument", examples=["val11"])
+            arg12: str = Field(description="the twelfth argument", examples=["val12"])
+            arg13: str = Field(
+                description="the thirteenth argument", examples=["val13"]
+            )
+            arg14: str = Field(
+                description="the fourteenth argument", examples=["val14"]
+            )
+            arg15: str = Field(description="the fifteenth argument", examples=["val15"])
+
+        query_tool_1 = vec_factory.create_rag_tool(
+            tool_name="rag_tool",
+            tool_description="""
+            A dummy tool that takes 15 arguments and returns a response (str) to the user query based on the data in this corpus.
+            We are using this tool to test the tool factory works and does not crash with OpenAI.
+            """,
+            tool_args_schema=QueryToolArgs,
+        )
+
+        agent = Agent(
+            tools=[query_tool_1],
+            topic="Sample topic",
+            custom_instructions="Call the tool with 15 arguments",
+            agent_config=fc_config_groq,
+        )
+        res = agent.chat("What is the stock price?")
+        self.assertIn("I don't know", str(res))
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_tools.py

@@ -9,6 +9,7 @@ from vectara_agentic.tools import (
 )
 from vectara_agentic.agent import Agent
 from vectara_agentic.agent_config import AgentConfig
+from vectara_agentic.types import AgentType, ModelProvider
 
 from llama_index.core.tools import FunctionTool
 
@@ -179,22 +180,57 @@ class TestToolsPackage(unittest.TestCase):
         query_tool_1 = vec_factory.create_rag_tool(
             tool_name="rag_tool",
             tool_description="""
-            A dummy tool that takes 20 arguments and returns a response (str) to the user query based on the data in this corpus.
+            A dummy tool that takes 15 arguments and returns a response (str) to the user query based on the data in this corpus.
             We are using this tool to test the tool factory works and does not crash with OpenAI.
             """,
             tool_args_schema=QueryToolArgs,
         )
 
-        config = AgentConfig()
+        # Test with 15 arguments which go over the 1024 limit.
+        config = AgentConfig(
+            agent_type=AgentType.OPENAI
+        )
         agent = Agent(
             tools=[query_tool_1],
             topic="Sample topic",
-            custom_instructions="Call the tool with 20 arguments",
+            custom_instructions="Call the tool with 15 arguments for OPENAI",
             agent_config=config,
         )
         res = agent.chat("What is the stock price?")
         self.assertIn("maximum length of 1024 characters", str(res))
 
+        # Same test but with GROQ
+        config = AgentConfig(
+            agent_type=AgentType.FUNCTION_CALLING,
+            main_llm_provider=ModelProvider.GROQ,
+            tool_llm_provider=ModelProvider.GROQ,
+        )
+        agent = Agent(
+            tools=[query_tool_1],
+            topic="Sample topic",
+            custom_instructions="Call the tool with 15 arguments for GROQ",
+            agent_config=config,
+        )
+        res = agent.chat("What is the stock price?")
+        self.assertNotIn("maximum length of 1024 characters", str(res))
+
+        # Same test but with ANTHROPIC
+        config = AgentConfig(
+            agent_type=AgentType.FUNCTION_CALLING,
+            main_llm_provider=ModelProvider.ANTHROPIC,
+            tool_llm_provider=ModelProvider.ANTHROPIC,
+        )
+        agent = Agent(
+            tools=[query_tool_1],
+            topic="Sample topic",
+            custom_instructions="Call the tool with 15 arguments for ANTHROPIC",
+            agent_config=config,
+        )
+        res = agent.chat("What is the stock price?")
+        # ANTHROPIC does not have that 1024 limit
+        self.assertIn("stock price", str(res))
+
+        # But using Compact_docstring=True, we can pass 15 arguments successfully.
         vec_factory = VectaraToolFactory(
             vectara_corpus_key, vectara_api_key, compact_docstring=True
         )
@@ -211,7 +247,7 @@ class TestToolsPackage(unittest.TestCase):
         agent = Agent(
             tools=[query_tool_2],
             topic="Sample topic",
-            custom_instructions="Call the tool with 20 arguments",
+            custom_instructions="Call the tool with 15 arguments",
             agent_config=config,
         )
         res = agent.chat("What is the stock price?")
@@ -227,7 +263,7 @@ class TestToolsPackage(unittest.TestCase):
             tool_name="ask_vectara",
             data_description="data from Vectara website",
             assistant_specialty="RAG as a service",
-            vectara_summarizer="mockingbird-1.0-2024-07-16",
+            vectara_summarizer="mockingbird-2.0",
         )
 
         self.assertIn(

tests/test_vectara_llms.py

@@ -51,17 +51,6 @@ class TestLLMPackage(unittest.TestCase):
 
     def test_vectara_mockingbird(self):
         vec_factory = VectaraToolFactory(vectara_corpus_key, vectara_api_key)
-
-        query_tool = vec_factory.create_rag_tool(
-            tool_name="rag_tool",
-            tool_description="""
-            Returns a response (str) to the user query based on the data in this corpus.
-            """,
-            vectara_summarizer="mockingbird-1.0-2024-07-16",
-        )
-        res = query_tool(query="What is Vectara?")
-        self.assertIn("Vectara is an end-to-end platform", str(res))
-
         query_tool = vec_factory.create_rag_tool(
             tool_name="rag_tool",
             tool_description="""

vectara_agentic/_version.py

@@ -1,4 +1,4 @@
 """
 Define the version of the package.
 """
-__version__ = "0.2.13"
+__version__ = "0.2.14"

vectara_agentic/agent.py

@@ -12,6 +12,8 @@ import logging
 import asyncio
 import importlib
 from collections import Counter
+import inspect
+from inspect import Signature, Parameter, ismethod
 
 import cloudpickle as pickle
 
@@ -19,6 +21,7 @@ from dotenv import load_dotenv
 
 from pydantic import Field, create_model, ValidationError
 
+
 from llama_index.core.memory import ChatMemoryBuffer
 from llama_index.core.llms import ChatMessage, MessageRole
 from llama_index.core.tools import FunctionTool
@@ -47,7 +50,7 @@ from .types import (
     AgentStreamingResponse,
     AgentConfigType,
 )
-from .utils import get_llm, get_tokenizer_for_model
+from .llm_utils import get_llm, get_tokenizer_for_model
 from ._prompts import (
     REACT_PROMPT_TEMPLATE,
     GENERAL_PROMPT_TEMPLATE,
@@ -230,6 +233,10 @@ class Agent:
         self.workflow_cls = workflow_cls
         self.workflow_timeout = workflow_timeout
 
+        # Sanitize tools for Gemini if needed
+        if self.agent_config.main_llm_provider == ModelProvider.GEMINI:
+            self.tools = self._sanitize_tools_for_gemini(self.tools)
+
         # Validate tools
         # Check for:
         # 1. multiple copies of the same tool
@@ -311,6 +318,63 @@ class Agent:
             print(f"Failed to set up observer ({e}), ignoring")
             self.observability_enabled = False
 
+    def _sanitize_tools_for_gemini(
+        self, tools: list[FunctionTool]
+    ) -> list[FunctionTool]:
+        """
+        Strip all default values from:
+        - tool.fn
+        - tool.async_fn
+        - tool.metadata.fn_schema
+        so Gemini sees *only* required parameters, no defaults.
+        """
+        for tool in tools:
+            # 1) strip defaults off the actual callables
+            for func in (tool.fn, tool.async_fn):
+                if not func:
+                    continue
+                orig_sig = inspect.signature(func)
+                new_params = [
+                    p.replace(default=Parameter.empty)
+                    for p in orig_sig.parameters.values()
+                ]
+                new_sig = Signature(
+                    new_params, return_annotation=orig_sig.return_annotation
+                )
+                if ismethod(func):
+                    func.__func__.__signature__ = new_sig
+                else:
+                    func.__signature__ = new_sig
+
+            # 2) rebuild the Pydantic schema so that *every* field is required
+            schema_cls = getattr(tool.metadata, "fn_schema", None)
+            if schema_cls and hasattr(schema_cls, "model_fields"):
+                # collect (name → (type, Field(...))) for all fields
+                new_fields: dict[str, tuple[type, Any]] = {}
+                for name, mf in schema_cls.model_fields.items():
+                    typ = mf.annotation
+                    desc = getattr(mf, "description", "")
+                    # force required (no default) with Field(...)
+                    new_fields[name] = (typ, Field(..., description=desc))
+
+                # make a brand-new schema class where every field is required
+                no_default_schema = create_model(
+                    f"{schema_cls.__name__}",  # new class name
+                    **new_fields,  # type: ignore
+                )
+
+                # give it a clean __signature__ so inspect.signature sees no defaults
+                params = [
+                    Parameter(n, Parameter.POSITIONAL_OR_KEYWORD, annotation=typ)
+                    for n, (typ, _) in new_fields.items()
+                ]
+                no_default_schema.__signature__ = Signature(params)
+
+                # swap it back onto the tool
+                tool.metadata.fn_schema = no_default_schema
+
+        return tools
+
     def _create_agent(
         self, config: AgentConfig, llm_callback_manager: CallbackManager
     ) -> Union[BaseAgent, AgentRunner]:

vectara_agentic/llm_utils.py

@@ -0,0 +1,174 @@
+"""
+Utilities for the Vectara agentic.
+"""
+from types import MethodType
+from typing import Tuple, Callable, Optional
+from functools import lru_cache
+import tiktoken
+
+from llama_index.core.llms import LLM
+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
+from .tool_utils import _updated_openai_prepare_chat_with_tools
+
+provider_to_default_model_name = {
+    ModelProvider.OPENAI: "gpt-4o",
+    ModelProvider.ANTHROPIC: "claude-3-7-sonnet-latest",
+    ModelProvider.TOGETHER: "Qwen/Qwen2.5-72B-Instruct-Turbo",
+    ModelProvider.GROQ: "meta-llama/llama-4-scout-17b-16e-instruct",
+    ModelProvider.FIREWORKS: "accounts/fireworks/models/firefunction-v2",
+    ModelProvider.BEDROCK: "anthropic.claude-3-7-sonnet-20250219-v1:0",
+    ModelProvider.COHERE: "command-a-03-2025",
+    ModelProvider.GEMINI: "models/gemini-2.0-flash",
+}
+
+DEFAULT_MODEL_PROVIDER = ModelProvider.OPENAI
+
+
+@lru_cache(maxsize=None)
+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(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(config.main_llm_provider)
+        model_name = config.main_llm_model_name or provider_to_default_model_name.get(
+            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_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
+    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.
+    """
+    max_tokens = 8192
+    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,
+            strict=True,
+            max_tokens=max_tokens,
+            pydantic_program_mode="openai",
+        )
+    elif model_provider == ModelProvider.ANTHROPIC:
+        llm = Anthropic(
+            model=model_name,
+            temperature=0,
+            max_tokens=max_tokens,
+        )
+    elif model_provider == ModelProvider.GEMINI:
+        from llama_index.llms.google_genai import GoogleGenAI
+
+        llm = GoogleGenAI(
+            model=model_name,
+            temperature=0,
+            is_function_calling_model=True,
+            allow_parallel_tool_calls=True,
+            max_tokens=max_tokens,
+        )
+    elif model_provider == ModelProvider.TOGETHER:
+        from llama_index.llms.together import TogetherLLM
+
+        llm = TogetherLLM(
+            model=model_name,
+            temperature=0,
+            is_function_calling_model=True,
+            max_tokens=max_tokens,
+        )
+        # pylint: disable=protected-access
+        llm._prepare_chat_with_tools = MethodType(
+            _updated_openai_prepare_chat_with_tools,
+            llm,
+        )
+    elif model_provider == ModelProvider.GROQ:
+        from llama_index.llms.groq import Groq
+
+        llm = Groq(
+            model=model_name,
+            temperature=0,
+            is_function_calling_model=True,
+            max_tokens=max_tokens,
+        )
+        # pylint: disable=protected-access
+        llm._prepare_chat_with_tools = MethodType(
+            _updated_openai_prepare_chat_with_tools,
+            llm,
+        )
+    elif model_provider == ModelProvider.FIREWORKS:
+        from llama_index.llms.fireworks import Fireworks
+
+        llm = Fireworks(model=model_name, temperature=0, max_tokens=max_tokens)
+    elif model_provider == ModelProvider.BEDROCK:
+        from llama_index.llms.bedrock import Bedrock
+
+        llm = Bedrock(model=model_name, temperature=0, max_tokens=max_tokens)
+    elif model_provider == ModelProvider.COHERE:
+        from llama_index.llms.cohere import Cohere
+
+        llm = Cohere(model=model_name, temperature=0, max_tokens=max_tokens)
+    elif model_provider == ModelProvider.PRIVATE:
+        from llama_index.llms.openai_like import OpenAILike
+
+        llm = OpenAILike(
+            model=model_name,
+            temperature=0,
+            is_function_calling_model=True,
+            is_chat_model=True,
+            api_base=config.private_llm_api_base,
+            api_key=config.private_llm_api_key,
+            max_tokens=max_tokens,
+        )
+        # pylint: disable=protected-access
+        llm._prepare_chat_with_tools = MethodType(
+            _updated_openai_prepare_chat_with_tools,
+            llm,
+        )
+
+    else:
+        raise ValueError(f"Unknown LLM provider: {model_provider}")
+    return llm