vectara-agentic 0.2.13__py3-none-any.whl → 0.2.15__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_return_direct.py

@@ -0,0 +1,49 @@
+import unittest
+
+from vectara_agentic.agent import Agent
+from vectara_agentic.tools import VectaraToolFactory
+
+vectara_corpus_key = "vectara-docs_1"
+vectara_api_key = "zqt_UXrBcnI2UXINZkrv4g1tQPhzj02vfdtqYJIDiA"
+
+
+class TestAgentPackage(unittest.TestCase):
+
+    def test_return_direct1(self):
+        vec_factory = VectaraToolFactory(vectara_corpus_key, vectara_api_key)
+
+        query_tool = vec_factory.create_rag_tool(
+            tool_name="rag_tool",
+            tool_description="""
+            A dummy tool for testing return_direct.
+            """,
+            return_direct=True,
+        )
+
+        agent = Agent(
+            tools=[query_tool],
+            topic="Sample topic",
+            custom_instructions="You are a helpful assistant.",
+        )
+        res = agent.chat("What is Vectara?")
+        self.assertIn("Response:", str(res))
+        self.assertIn("fcs_score", str(res))
+        self.assertIn("References:", str(res))
+
+    def test_from_corpus(self):
+        agent = Agent.from_corpus(
+            tool_name="rag_tool",
+            vectara_corpus_key=vectara_corpus_key,
+            vectara_api_key=vectara_api_key,
+            data_description="stuff about Vectara",
+            assistant_specialty="question answering",
+            return_direct=True,
+        )
+        res = agent.chat("What is Vectara?")
+        self.assertIn("Response:", str(res))
+        self.assertIn("fcs_score", str(res))
+        self.assertIn("References:", 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?")
+        res = agent.chat("What is the stock price for Yahoo on 12/31/22?")
         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

@@ -15,7 +15,10 @@ vectara_api_key = "zqt_UXrBcnI2UXINZkrv4g1tQPhzj02vfdtqYJIDiA"
 class TestLLMPackage(unittest.TestCase):
 
     def test_vectara_openai(self):
-        vec_factory = VectaraToolFactory(vectara_corpus_key, vectara_api_key)
+        vec_factory = VectaraToolFactory(
+            vectara_corpus_key=vectara_corpus_key,
+            vectara_api_key=vectara_api_key
+        )
 
         self.assertEqual(vectara_corpus_key, vec_factory.vectara_corpus_key)
         self.assertEqual(vectara_api_key, vec_factory.vectara_api_key)
@@ -51,17 +54,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/_observability.py

@@ -12,28 +12,50 @@ def setup_observer(config: AgentConfig, verbose: bool) -> bool:
     '''
     Setup the observer.
     '''
-    import phoenix as px
-    from openinference.instrumentation.llama_index import LlamaIndexInstrumentor
-    from phoenix.otel import register
-    if config.observer == ObserverType.ARIZE_PHOENIX:
-        phoenix_endpoint = os.getenv("PHOENIX_ENDPOINT", None)
-        if not phoenix_endpoint:
-            px.launch_app()
-            tracer_provider = register(endpoint='http://localhost:6006/v1/traces', project_name="vectara-agentic")
-        elif 'app.phoenix.arize.com' in phoenix_endpoint:   # hosted on Arize
-            phoenix_api_key = os.getenv("PHOENIX_API_KEY", None)
-            if not phoenix_api_key:
-                raise ValueError("Arize Phoenix API key not set. Please set PHOENIX_API_KEY environment variable.")
-            os.environ["PHOENIX_CLIENT_HEADERS"] = f"api_key={phoenix_api_key}"
-            os.environ["PHOENIX_COLLECTOR_ENDPOINT"] = "https://app.phoenix.arize.com"
-            tracer_provider = register(endpoint=phoenix_endpoint, project_name="vectara-agentic")
-        else:       # Self hosted Phoenix
-            tracer_provider = register(endpoint=phoenix_endpoint, project_name="vectara-agentic")
-        LlamaIndexInstrumentor().instrument(tracer_provider=tracer_provider)
-        return True
+    if config.observer != ObserverType.ARIZE_PHOENIX:
+        if verbose:
+            print("No Phoenix observer set.")
+        return False
+
+    try:
+        import phoenix as px
+        from openinference.instrumentation.llama_index import LlamaIndexInstrumentor
+        from phoenix.otel import register
+    except ImportError:
+        print(
+            (
+                "Phoenix libraries not found. Please install with"
+                "'pip install arize-phoenix openinference-instrumentation-llama-index'"
+            )
+        )
+        return False
+
+    phoenix_endpoint = os.getenv("PHOENIX_ENDPOINT", None)
+    if not phoenix_endpoint:
+        print("Phoenix endpoint not set. Attempting to launch local Phoenix UI...")
+        px.launch_app()
+        print("Local Phoenix UI launched. You can view traces at the UI address (usually http://localhost:6006).")
+
+    if phoenix_endpoint and 'app.phoenix.arize.com' in phoenix_endpoint:
+        phoenix_api_key = os.getenv("PHOENIX_API_KEY")
+        if not phoenix_api_key:
+            raise ValueError(
+                "Arize Phoenix API key not set. Please set PHOENIX_API_KEY."
+            )
+        os.environ["PHOENIX_CLIENT_HEADERS"] = f"api_key={phoenix_api_key}"
+        os.environ["PHOENIX_COLLECTOR_ENDPOINT"] = "https://app.phoenix.arize.com"
+
+    reg_kwargs = {
+        "endpoint": phoenix_endpoint or 'http://localhost:6006/v1/traces',
+        "project_name": "vectara-agentic",
+        "batch": True,
+        "set_global_tracer_provider": False,
+    }
+    tracer_provider = register(**reg_kwargs)
+    LlamaIndexInstrumentor().instrument(tracer_provider=tracer_provider)
     if verbose:
-        print("No observer set.")
-    return False
+        print(f"Phoenix observer configured for project 'vectara-agentic' at endpoint: {reg_kwargs['endpoint']}")
+    return True
 
 
 def _extract_fcs_value(output: Union[str, dict]) -> Optional[float]:

vectara_agentic/_prompts.py

@@ -5,7 +5,7 @@ This file contains the prompt templates for the different types of agents.
 # General (shared) instructions
 GENERAL_INSTRUCTIONS = """
 - Use tools as your main source of information, do not respond without using a tool. Do not respond based on pre-trained knowledge.
-- Use the 'get_bad_topics' tool to determine the topics you are not allowed to discuss or respond to.
+- Use the 'get_bad_topics' (if it exists) tool to determine the topics you are not allowed to discuss or respond to.
 - Before responding to a user query that requires knowledge of the current date, call the 'get_current_date' tool to get the current date.
   Never rely on previous knowledge of the current date.
   Example queries that require the current date: "What is the revenue of Apple last october?" or "What was the stock price 5 days ago?".

vectara_agentic/_version.py

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

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
@@ -241,19 +248,25 @@ class Agent:
 
         if validate_tools:
             prompt = f"""
-            Given the following instructions, and a list of tool names,
-            Please identify tools mentioned in the instructions that do not exist in the list.
-            Instructions:
+            You are provided these tools:
+            <tools>{','.join(tool_names)}</tools>
+            And these instructions:
+            <instructions>
             {self._custom_instructions}
-            Tool names: {', '.join(tool_names)}
-            Your response should include a comma separated list of tool names that do not exist in the list.
-            Your response should be an empty string if all tools mentioned in the instructions are in the list.
+            </instructions>
+            Your task is to identify invalid tools.
+            A tool is invalid if it is mentioned in the instructions but not in the tools list.
+            A tool's name must have at least two characters.
+            Your response should be a comma-separated list of the invalid tools.
+            If not invalid tools exist, respond with "<OKAY>".
             """
             llm = get_llm(LLMRole.MAIN, config=self.agent_config)
-            bad_tools = llm.complete(prompt).text.split(", ")
-            if bad_tools:
+            bad_tools_str = llm.complete(prompt).text
+            if bad_tools_str and bad_tools_str != "<OKAY>":
+                bad_tools = [tool.strip() for tool in bad_tools_str.split(",")]
+                numbered = ", ".join(f"({i}) {tool}" for i, tool in enumerate(bad_tools, 1))
                 raise ValueError(
-                    f"The Agent custom instructions mention these invalid tools: {', '.join(bad_tools)}"
+                    f"The Agent custom instructions mention these invalid tools: {numbered}"
                 )
 
         # Create token counters for the main and tool LLMs
@@ -311,6 +324,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]:
@@ -625,6 +695,7 @@ class Agent:
         vectara_frequency_penalty: Optional[float] = None,
         vectara_presence_penalty: Optional[float] = None,
         vectara_save_history: bool = True,
+        return_direct: bool = False,
     ) -> "Agent":
         """
         Create an agent from a single Vectara corpus
@@ -674,6 +745,7 @@ class Agent:
             vectara_presence_penalty (float, optional): How much to penalize repeating tokens in the response,
                 higher values increasing the diversity of topics.
             vectara_save_history (bool, optional): Whether to save the query in history.
+            return_direct (bool, optional): Whether the agent should return the tool's response directly.
 
         Returns:
             Agent: An instance of the Agent class.
@@ -727,6 +799,7 @@ class Agent:
             save_history=vectara_save_history,
             include_citations=True,
             verbose=verbose,
+            return_direct=return_direct,
         )
 
         assistant_instructions = f"""