vectara-agentic 0.2.6__tar.gz → 0.2.7__tar.gz

{vectara_agentic-0.2.6/vectara_agentic.egg-info → vectara_agentic-0.2.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vectara_agentic
-Version: 0.2.6
+Version: 0.2.7
 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

vectara_agentic-0.2.7/tests/test_agent.py

@@ -0,0 +1,162 @@
+import unittest
+import threading
+from datetime import date
+
+from vectara_agentic.agent import _get_prompt, Agent, AgentType
+from vectara_agentic.agent_config import AgentConfig
+from vectara_agentic.types import ModelProvider, ObserverType
+from vectara_agentic.tools import ToolsFactory
+
+def mult(x: float, y: float) -> float:
+    return x * y
+
+
+ARIZE_LOCK = threading.Lock()
+
+class TestAgentPackage(unittest.TestCase):
+    def test_get_prompt(self):
+        prompt_template = "{chat_topic} on {today} with {custom_instructions}"
+        topic = "Programming"
+        custom_instructions = "Always do as your mother tells you!"
+        expected_output = (
+            "Programming on "
+            + date.today().strftime("%A, %B %d, %Y")
+            + " with Always do as your mother tells you!"
+        )
+        self.assertEqual(
+            _get_prompt(prompt_template, topic, custom_instructions), expected_output
+        )
+
+    def test_agent_init(self):
+        tools = [ToolsFactory().create_tool(mult)]
+        topic = "AI"
+        custom_instructions = "Always do as your mother tells you!"
+        agent = Agent(tools, topic, custom_instructions)
+        self.assertEqual(agent.agent_type, AgentType.OPENAI)
+        self.assertEqual(agent._topic, topic)
+        self.assertEqual(agent._custom_instructions, custom_instructions)
+
+        # 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"
+            ).response.replace("$", "\\$"),
+            "50",
+        )
+
+    def test_agent_config(self):
+        with ARIZE_LOCK:
+            tools = [ToolsFactory().create_tool(mult)]
+            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._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 ANTHROPIC_API_KEY and TOGETHER_API_KEY in your environment
+            self.assertEqual(
+                agent.chat(
+                    "What is 5 times 10. Only give the answer, nothing else"
+                ).response.replace("$", "\\$"),
+                "50",
+            )
+
+    def test_multiturn(self):
+        tools = [ToolsFactory().create_tool(mult)]
+        topic = "AI topic"
+        instructions = "Always do as your father tells you, if your mother agrees!"
+        agent = Agent(
+            tools=tools,
+            topic=topic,
+            custom_instructions=instructions,
+        )
+
+        agent.chat("What is 5 times 10. Only give the answer, nothing else")
+        agent.chat("what is 3 times 7. Only give the answer, nothing else")
+        res = agent.chat("multiply the results of the last two questions. Output only the answer.")
+        self.assertEqual(res.response, "1050")
+
+    def test_from_corpus(self):
+        agent = Agent.from_corpus(
+            tool_name="RAG Tool",
+            vectara_corpus_key="corpus_key",
+            vectara_api_key="api_key",
+            data_description="information",
+            assistant_specialty="question answering",
+        )
+
+        self.assertIsInstance(agent, Agent)
+        self.assertEqual(agent._topic, "question answering")
+
+    def test_serialization(self):
+        with ARIZE_LOCK:
+            config = AgentConfig(
+                agent_type=AgentType.REACT,
+                main_llm_provider=ModelProvider.ANTHROPIC,
+                tool_llm_provider=ModelProvider.TOGETHER,
+                observer=ObserverType.ARIZE_PHOENIX
+            )
+
+            agent = Agent.from_corpus(
+                tool_name="RAG Tool",
+                agent_config=config,
+                vectara_corpus_key="corpus_key",
+                vectara_api_key="api_key",
+                data_description="information",
+                assistant_specialty="question answering",
+            )
+
+            agent_reloaded = agent.loads(agent.dumps())
+            agent_reloaded_again = agent_reloaded.loads(agent_reloaded.dumps())
+
+            self.assertIsInstance(agent_reloaded, Agent)
+            self.assertEqual(agent, agent_reloaded)
+            self.assertEqual(agent.agent_type, agent_reloaded.agent_type)
+
+            self.assertEqual(agent.agent_config.observer, agent_reloaded.agent_config.observer)
+            self.assertEqual(agent.agent_config.main_llm_provider, agent_reloaded.agent_config.main_llm_provider)
+            self.assertEqual(agent.agent_config.tool_llm_provider, agent_reloaded.agent_config.tool_llm_provider)
+
+            self.assertIsInstance(agent_reloaded, Agent)
+            self.assertEqual(agent, agent_reloaded_again)
+            self.assertEqual(agent.agent_type, agent_reloaded_again.agent_type)
+
+            self.assertEqual(agent.agent_config.observer, agent_reloaded_again.agent_config.observer)
+            self.assertEqual(agent.agent_config.main_llm_provider, agent_reloaded_again.agent_config.main_llm_provider)
+            self.assertEqual(agent.agent_config.tool_llm_provider, agent_reloaded_again.agent_config.tool_llm_provider)
+
+    def test_chat_history(self):
+        tools = [ToolsFactory().create_tool(mult)]
+        topic = "AI topic"
+        instructions = "Always do as your father tells you, if your mother agrees!"
+        agent = Agent(
+            tools=tools,
+            topic=topic,
+            custom_instructions=instructions,
+            chat_history=[("What is 5 times 10", "50"), ("What is 3 times 7", "21")]
+        )
+
+        res = agent.chat("multiply the results of the last two questions. Output only the answer.")
+        self.assertEqual(res.response, "1050")
+
+
+if __name__ == "__main__":
+    unittest.main()

vectara_agentic-0.2.7/tests/test_agent_planning.py

@@ -0,0 +1,73 @@
+import unittest
+
+from vectara_agentic.agent_config import AgentConfig
+from vectara_agentic.agent import Agent
+from vectara_agentic.tools import VectaraToolFactory
+
+from pydantic import Field, BaseModel
+
+
+# SETUP speical test account credentials for vectara
+# It's okay to expose these credentials in the test code
+vectara_corpus_key = "vectara-docs_1"
+vectara_api_key = 'zqt_UXrBcnI2UXINZkrv4g1tQPhzj02vfdtqYJIDiA'
+
+
+class QueryArgs(BaseModel):
+    query: str = Field(..., description="The user query, always in the form of a question.")
+
+
+vec_factory = VectaraToolFactory(vectara_api_key=vectara_api_key,
+                                 vectara_corpus_key=vectara_corpus_key)
+summarizer = 'vectara-summary-table-md-query-ext-jan-2025-gpt-4o'
+ask_vectara = vec_factory.create_rag_tool(
+    tool_name = "ask_vectara",
+    tool_description = "This tool can respond to questions about Vectara.",
+    tool_args_schema = QueryArgs,
+    reranker = "multilingual_reranker_v1", rerank_k = 100, rerank_cutoff = 0.1,
+    n_sentences_before = 2, n_sentences_after = 2, lambda_val = 0.005,
+    summary_num_results = 10,
+    vectara_summarizer = summarizer,
+    include_citations = True,
+    verbose=False,
+)
+
+class TestAgentPlanningPackage(unittest.TestCase):
+
+    def test_no_planning(self):
+        tools = [ask_vectara]
+        topic = "vectara"
+        instructions = "Answer user queries about Vectara."
+
+        query = "What is Vectara and what demos are available of the Vectara platform?"
+        agent = Agent(
+            tools=tools,
+            topic=topic,
+            custom_instructions=instructions,
+            agent_config=AgentConfig(),
+        )
+        res = agent.chat(query)
+        self.assertIn("demos", res.response)
+        self.assertIn("Vectara", res.response)
+
+    def test_structured_planning(self):
+        tools = [ask_vectara]
+        topic = "vectara"
+        instructions = "Answer user queries about Vectara."
+
+        query = "What is Vectara and what demos are available of the Vectara platform?"
+        agent = Agent(
+            tools=tools,
+            topic=topic,
+            custom_instructions=instructions,
+            agent_config=AgentConfig(),
+            use_structured_planning=True,
+        )
+
+        res = agent.chat(query)
+        self.assertIn("demos", res.response)
+        self.assertIn("Vectara", res.response)
+
+
+if __name__ == "__main__":
+    unittest.main()

vectara_agentic-0.2.7/tests/test_agent_type.py

@@ -0,0 +1,157 @@
+import unittest
+
+from vectara_agentic.agent import Agent, AgentType
+from vectara_agentic.agent_config import AgentConfig
+from vectara_agentic.tools import ToolsFactory
+from vectara_agentic.types import ModelProvider
+
+import nest_asyncio
+nest_asyncio.apply()
+
+def mult(x: float, y: float) -> float:
+    return x * y
+
+
+react_config_anthropic = AgentConfig(
+    agent_type=AgentType.REACT,
+    main_llm_provider=ModelProvider.ANTHROPIC,
+    tool_llm_provider=ModelProvider.ANTHROPIC,
+)
+
+react_config_gemini = AgentConfig(
+    agent_type=AgentType.REACT,
+    main_llm_provider=ModelProvider.GEMINI,
+    tool_llm_provider=ModelProvider.GEMINI,
+)
+
+react_config_together = AgentConfig(
+    agent_type=AgentType.REACT,
+    main_llm_provider=ModelProvider.TOGETHER,
+    tool_llm_provider=ModelProvider.TOGETHER,
+)
+
+fc_config_anthropic = AgentConfig(
+    agent_type=AgentType.FUNCTION_CALLING,
+    main_llm_provider=ModelProvider.ANTHROPIC,
+    tool_llm_provider=ModelProvider.ANTHROPIC,
+)
+
+fc_config_gemini = AgentConfig(
+    agent_type=AgentType.FUNCTION_CALLING,
+    main_llm_provider=ModelProvider.GEMINI,
+    tool_llm_provider=ModelProvider.GEMINI,
+)
+
+fc_config_together = AgentConfig(
+    agent_type=AgentType.FUNCTION_CALLING,
+    main_llm_provider=ModelProvider.TOGETHER,
+    tool_llm_provider=ModelProvider.TOGETHER,
+)
+
+
+openai_config = AgentConfig(
+    agent_type=AgentType.OPENAI,
+)
+
+class TestAgentType(unittest.TestCase):
+
+    def test_openai(self):
+        tools = [ToolsFactory().create_tool(mult)]
+        topic = "AI topic"
+        instructions = "Always do as your father tells you, if your mother agrees!"
+        agent = Agent(
+            agent_config=openai_config,
+            tools=tools,
+            topic=topic,
+            custom_instructions=instructions,
+        )
+
+        agent.chat("What is 5 times 10. Only give the answer, nothing else")
+        agent.chat("what is 3 times 7. Only give the answer, nothing else")
+        res = agent.chat("multiply the results of the last two multiplications. Only give the answer, nothing else.")
+        self.assertIn("1050", res.response)
+
+    def test_gemini(self):
+        tools = [ToolsFactory().create_tool(mult)]
+        topic = "AI topic"
+        instructions = "Always do as your father tells you, if your mother agrees!"
+
+        agent = Agent(
+            agent_config=react_config_gemini,
+            tools=tools,
+            topic=topic,
+            custom_instructions=instructions,
+        )
+        agent.chat("What is 5 times 10. Only give the answer, nothing else")
+        agent.chat("what is 3 times 7. Only give the answer, nothing else")
+        res = agent.chat("multiply the results of the last two multiplications. Only give the answer, nothing else.")
+        self.assertIn("1050", res.response)
+
+        agent = Agent(
+            agent_config=fc_config_gemini,
+            tools=tools,
+            topic=topic,
+            custom_instructions=instructions,
+        )
+        agent.chat("What is 5 times 10. Only give the answer, nothing else")
+        agent.chat("what is 3 times 7. Only give the answer, nothing else")
+        res = agent.chat("multiply the results of the last two multiplications. Only give the answer, nothing else.")
+        self.assertIn("1050", res.response)
+
+    def test_together(self):
+        tools = [ToolsFactory().create_tool(mult)]
+        topic = "AI topic"
+        instructions = "Always do as your father tells you, if your mother agrees!"
+
+        agent = Agent(
+            agent_config=react_config_together,
+            tools=tools,
+            topic=topic,
+            custom_instructions=instructions,
+        )
+        agent.chat("What is 5 times 10. Only give the answer, nothing else")
+        agent.chat("what is 3 times 7. Only give the answer, nothing else")
+        res = agent.chat("multiply the results of the last two multiplications. Only give the answer, nothing else.")
+        self.assertIn("1050", res.response)
+
+        agent = Agent(
+            agent_config=fc_config_together,
+            tools=tools,
+            topic=topic,
+            custom_instructions=instructions,
+        )
+        agent.chat("What is 5 times 10. Only give the answer, nothing else")
+        agent.chat("what is 3 times 7. Only give the answer, nothing else")
+        res = agent.chat("multiply the results of the last two multiplications. Only give the answer, nothing else.")
+        self.assertIn("1050", res.response)
+
+    def test_anthropic(self):
+        tools = [ToolsFactory().create_tool(mult)]
+        topic = "AI topic"
+        instructions = "Always do as your father tells you, if your mother agrees!"
+
+        agent = Agent(
+            agent_config=react_config_anthropic,
+            tools=tools,
+            topic=topic,
+            custom_instructions=instructions,
+        )
+        agent.chat("What is 5 times 10. Only give the answer, nothing else")
+        agent.chat("what is 3 times 7. Only give the answer, nothing else")
+        res = agent.chat("multiply the results of the last two multiplications. Only give the answer, nothing else.")
+        self.assertIn("1050", res.response)
+
+        agent = Agent(
+            agent_config=fc_config_anthropic,
+            tools=tools,
+            topic=topic,
+            custom_instructions=instructions,
+        )
+        agent.chat("What is 5 times 10. Only give the answer, nothing else")
+        agent.chat("what is 3 times 7. Only give the answer, nothing else")
+        res = agent.chat("multiply the results of the last two multiplications. Only give the answer, nothing else.")
+        self.assertIn("1050", res.response)
+
+
+if __name__ == "__main__":
+    unittest.main()

{vectara_agentic-0.2.6 → vectara_agentic-0.2.7}/tests/test_fallback.py

@@ -40,8 +40,8 @@ class TestFallback(unittest.TestCase):
         cls.flask_process.send_signal(signal.SIGINT)
         cls.flask_process.wait()
 
-    def test_fallback(self):
-        def mult(x, y):
+    def test_fallback_from_private(self):
+        def mult(x: float, y: float) -> float:
             return x * y
 
         tools = [ToolsFactory().create_tool(mult)]

{vectara_agentic-0.2.6 → vectara_agentic-0.2.7}/tests/test_private_llm.py

@@ -41,7 +41,7 @@ class TestPrivateLLM(unittest.TestCase):
         cls.flask_process.wait()
 
     def test_endpoint(self):
-        def mult(x, y):
+        def mult(x: float, y: float) -> float:
             return x * y
 
         tools = [ToolsFactory().create_tool(mult)]

{vectara_agentic-0.2.6 → vectara_agentic-0.2.7}/tests/test_tools.py

@@ -47,7 +47,7 @@ class TestToolsPackage(unittest.TestCase):
         self.assertEqual(search_tool.metadata.tool_type, ToolType.QUERY)
 
     def test_tool_factory(self):
-        def mult(x, y):
+        def mult(x: float, y: float) -> float:
             return x * y
 
         tools_factory = ToolsFactory()

{vectara_agentic-0.2.6 → vectara_agentic-0.2.7}/vectara_agentic/_version.py

@@ -1,4 +1,4 @@
 """
 Define the version of the package.
 """
-__version__ = "0.2.6"
+__version__ = "0.2.7"

{vectara_agentic-0.2.6 → vectara_agentic-0.2.7}/vectara_agentic/agent.py

@@ -21,7 +21,7 @@ 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
-from llama_index.core.agent import ReActAgent, StructuredPlannerAgent
+from llama_index.core.agent import ReActAgent, StructuredPlannerAgent, FunctionCallingAgent
 from llama_index.core.agent.react.formatter import ReActChatFormatter
 from llama_index.agent.llm_compiler import LLMCompilerAgentWorker
 from llama_index.agent.lats import LATSAgentWorker
@@ -277,7 +277,19 @@ class Agent:
         llm = get_llm(LLMRole.MAIN, config=config)
         llm.callback_manager = llm_callback_manager
 
-        if agent_type == AgentType.REACT:
+        if agent_type == AgentType.FUNCTION_CALLING:
+            prompt = _get_prompt(GENERAL_PROMPT_TEMPLATE, self._topic, self._custom_instructions)
+            agent = FunctionCallingAgent.from_tools(
+                tools=self.tools,
+                llm=llm,
+                memory=self.memory,
+                verbose=self.verbose,
+                max_function_calls=config.max_reasoning_steps,
+                callback_manager=llm_callback_manager,
+                system_prompt = prompt,
+                allow_parallel_tool_calls=True,
+            )
+        elif agent_type == AgentType.REACT:
             prompt = _get_prompt(REACT_PROMPT_TEMPLATE, self._topic, self._custom_instructions)
             agent = ReActAgent.from_tools(
                 tools=self.tools,
@@ -295,7 +307,7 @@ class Agent:
                 llm=llm,
                 memory=self.memory,
                 verbose=self.verbose,
-                callable_manager=llm_callback_manager,
+                callback_manager=llm_callback_manager,
                 max_function_calls=config.max_reasoning_steps,
                 system_prompt=prompt,
             )
@@ -304,7 +316,7 @@ class Agent:
                 tools=self.tools,
                 llm=llm,
                 verbose=self.verbose,
-                callable_manager=llm_callback_manager,
+                callback_manager=llm_callback_manager,
             )
             agent_worker.system_prompt = _get_prompt(
                 _get_llm_compiler_prompt(agent_worker.system_prompt, self._topic, self._custom_instructions),
@@ -322,7 +334,7 @@ class Agent:
                 num_expansions=3,
                 max_rollouts=-1,
                 verbose=self.verbose,
-                callable_manager=llm_callback_manager,
+                callback_manager=llm_callback_manager,
             )
             prompt = _get_prompt(REACT_PROMPT_TEMPLATE, self._topic, self._custom_instructions)
             agent_worker.chat_formatter = ReActChatFormatter(system_header=prompt)
@@ -707,6 +719,8 @@ class Agent:
         """
         max_attempts = 4 if self.fallback_agent_config else 2
         attempt = 0
+        orig_llm = self.llm.metadata.model_name
+        last_error = None
         while attempt < max_attempts:
             try:
                 current_agent = self._get_current_agent()
@@ -718,16 +732,20 @@ class Agent:
                     self.query_logging_callback(prompt, agent_response.response)
                 return agent_response
 
-            except Exception:
+            except Exception as e:
+                last_error = e
                 if attempt >= 2:
                     if self.verbose:
-                        print(f"LLM call failed on attempt {attempt+1}. Switching agent configuration.")
+                        print(f"LLM call failed on attempt {attempt}. Switching agent configuration.")
                     self._switch_agent_config()
                 time.sleep(1)
                 attempt += 1
 
         return AgentResponse(
-            response=f"LLM failure can't be resolved after {max_attempts} attempts."
+            response=(
+                f"For {orig_llm} LLM - failure can't be resolved after "
+                f"{max_attempts} attempts ({last_error}."
+            )
         )
 
     def stream_chat(self, prompt: str) -> AgentStreamingResponse:    # type: ignore

{vectara_agentic-0.2.6 → vectara_agentic-0.2.7}/vectara_agentic/sub_query_workflow.py

@@ -252,8 +252,10 @@ class SequentialSubQuestionsWorkflow(Workflow):
             As an example, for the question
             "what is the name of the mayor of the largest city within 50 miles of San Francisco?",
             the sub-questions could be:
-            - What is the largest city within 50 miles of San Francisco? (answer is San Jose)
-            - What is the name of the mayor of San Jose?
+            - What is the largest city within 50 miles of San Francisco?
+            - Who is the mayor of this city?
+            The answer to the first question is San Jose, which is given as context to the second question.
+            The answer to the second question is Matt Mahan.
             Here is the user question: {await ctx.get('original_query')}.
             Here are previous chat messages: {chat_history}.
             And here is the list of tools: {await ctx.get('tools')}
@@ -277,7 +279,16 @@ class SequentialSubQuestionsWorkflow(Workflow):
         if await ctx.get("verbose"):
             print(f"Sub-question is {ev.question}")
         agent = await ctx.get("agent")
-        response = await agent.achat(ev.question)
+        sub_questions = await ctx.get("sub_questions")
+        if ev.prev_answer:
+            prev_question = sub_questions[ev.num - 1]
+            prompt = f"""
+                The answer to the question '{prev_question}' is: '{ev.prev_answer}'
+                Now answer the following question: '{ev.question}'
+            """
+            response = await agent.achat(prompt)
+        else:
+            response = await agent.achat(ev.question)
         if await ctx.get("verbose"):
             print(f"Answer is {response}")
 
@@ -286,7 +297,8 @@ class SequentialSubQuestionsWorkflow(Workflow):
             return self.QueryEvent(
                 question=sub_questions[ev.num + 1],
                 prev_answer = response.response,
-                num=ev.num + 1)
+                num=ev.num + 1
+            )
 
         output = self.OutputsModel(response=response.response)
         return StopEvent(result=output)

{vectara_agentic-0.2.6 → vectara_agentic-0.2.7}/vectara_agentic/tools.py

@@ -8,7 +8,7 @@ import importlib
 import os
 
 from typing import Callable, List, Dict, Any, Optional, Union, Type
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field, create_model
 from pydantic_core import PydanticUndefined
 
 from llama_index.core.tools import FunctionTool
@@ -21,7 +21,7 @@ from llama_index.core.workflow.context import Context
 from .types import ToolType
 from .tools_catalog import ToolsCatalog, get_bad_topics
 from .db_tools import DBLoadSampleData, DBLoadUniqueValues, DBLoadData
-from .utils import is_float
+from .utils import is_float, summarize_vectara_document
 from .agent_config import AgentConfig
 
 LI_packages = {
@@ -74,6 +74,7 @@ class VectaraToolMetadata(ToolMetadata):
         base_repr = super().__repr__()
         return f"{base_repr}, tool_type={self.tool_type}"
 
+
 class VectaraTool(FunctionTool):
     """
     A subclass of FunctionTool adding the tool_type attribute.
@@ -161,7 +162,7 @@ class VectaraTool(FunctionTool):
         self, *args: Any, ctx: Optional[Context] = None, **kwargs: Any
     ) -> ToolOutput:
         try:
-            return super().call(*args, ctx=ctx, **kwargs)
+            return await super().acall(*args, ctx=ctx, **kwargs)
         except Exception as e:
             err_output = ToolOutput(
                 tool_name=self.metadata.name,
@@ -171,6 +172,65 @@ class VectaraTool(FunctionTool):
             )
             return err_output
 
+def _create_tool_from_dynamic_function(
+    function: Callable[..., ToolOutput],
+    tool_name: str,
+    tool_description: str,
+    base_params: list[inspect.Parameter],
+    tool_args_schema: type[BaseModel],
+) -> VectaraTool:
+    """
+    Create a VectaraTool from a dynamic function, including
+    setting the function signature and creating the tool schema.
+    """
+    fields = {}
+    for param in base_params:
+        default_value = param.default if param.default != inspect.Parameter.empty else ...
+        fields[param.name] = (param.annotation, default_value)
+    for field_name, field_info in tool_args_schema.model_fields.items():
+        if field_name not in fields:
+            default_value = field_info.default if field_info.default is not PydanticUndefined else ...
+            fields[field_name] = (field_info.annotation, default_value)
+    fn_schema = create_model(f"{tool_name}", **fields)
+
+    schema_params = [
+        inspect.Parameter(
+            name=field_name,
+            kind=inspect.Parameter.POSITIONAL_OR_KEYWORD,
+            default=field_info.default if field_info.default is not PydanticUndefined else inspect.Parameter.empty,
+            annotation=field_info.annotation if hasattr(field_info, 'annotation') else field_info,
+        )
+        for field_name, field_info in tool_args_schema.model_fields.items()
+        if field_name not in [p.name for p in base_params]
+    ]
+    all_params = base_params + schema_params
+
+    required_params = [p for p in all_params if p.default is inspect.Parameter.empty]
+    optional_params = [p for p in all_params if p.default is not inspect.Parameter.empty]
+    sig = inspect.Signature(required_params + optional_params)
+    function.__signature__ = sig
+    function.__annotations__["return"] = dict[str, Any]
+    function.__name__ = "_" + re.sub(r"[^A-Za-z0-9_]", "_", tool_name)
+
+    # Create the tool function signature string
+    param_strs = []
+    for param in all_params:
+        annotation = param.annotation
+        type_name = annotation.__name__ if hasattr(annotation, '__name__') else str(annotation)
+        param_strs.append(f"{param.name}: {type_name}")
+    args_str = ", ".join(param_strs)
+    function_str = f"{tool_name}({args_str}) -> str"
+
+    # Create the tool
+    tool = VectaraTool.from_defaults(
+        fn=function,
+        name=tool_name,
+        description=function_str + "\n" + tool_description,
+        fn_schema=fn_schema,
+        tool_type=ToolType.QUERY,
+    )
+    return tool
+
 def _build_filter_string(kwargs: Dict[str, Any], tool_args_type: Dict[str, dict], fixed_filter: str) -> str:
     """
     Build filter string for Vectara from kwargs
@@ -196,7 +256,7 @@ def _build_filter_string(kwargs: Dict[str, Any], tool_args_type: Dict[str, dict]
 
         if value is PydanticUndefined:
             raise ValueError(
-                f"Value of argument {key} is undefined, and this is invalid. "
+                f"Value of argument {key} is undefined, and this is invalid."
                 "Please form proper arguments and try again."
             )
 
@@ -394,7 +454,7 @@ class VectaraToolFactory:
         )
 
         # Dynamically generate the search function
-        def search_function(*args, **kwargs) -> ToolOutput:
+        def search_function(*args: Any, **kwargs: Any) -> ToolOutput:
             """
             Dynamically generated function for semantic search Vectara.
             """
@@ -406,6 +466,7 @@ class VectaraToolFactory:
 
             query = kwargs.pop("query")
             top_k = kwargs.pop("top_k", 10)
+            summarize = kwargs.pop("summarize", True)
             try:
                 filter_string = _build_filter_string(kwargs, tool_args_type, fixed_filter)
             except ValueError as e:
@@ -453,7 +514,11 @@ class VectaraToolFactory:
                 if doc.id_ in unique_ids:
                     continue
                 unique_ids.add(doc.id_)
-                tool_output += f"document_id: '{doc.id_}'\nmetadata: '{doc.metadata}'\n"
+                if summarize:
+                    summary = summarize_vectara_document(self.vectara_corpus_key, self.vectara_api_key, doc.id_)
+                    tool_output += f"document_id: '{doc.id_}'\nmetadata: '{doc.metadata}'\nsummary: '{summary}'\n\n"
+                else:
+                    tool_output += f"document_id: '{doc.id_}'\nmetadata: '{doc.metadata}'\n\n"
             out = ToolOutput(
                 tool_name=search_function.__name__,
                 content=tool_output,
@@ -462,42 +527,22 @@ class VectaraToolFactory:
             )
             return out
 
-        fields = tool_args_schema.model_fields
-        params = [
-            inspect.Parameter(
-                name=field_name,
-                kind=inspect.Parameter.POSITIONAL_OR_KEYWORD,
-                default=field_info.default,
-                annotation=field_info,
-            )
-            for field_name, field_info in fields.items()
+        base_params = [
+            inspect.Parameter("query", inspect.Parameter.POSITIONAL_OR_KEYWORD, annotation=str),
+            inspect.Parameter("top_k", inspect.Parameter.POSITIONAL_OR_KEYWORD, default=10, annotation=int),
+            inspect.Parameter("summarize", inspect.Parameter.POSITIONAL_OR_KEYWORD, default=True, annotation=bool),
         ]
-
-        # Create a new signature using the extracted parameters
-        sig = inspect.Signature(params)
-        search_function.__signature__ = sig
-        search_function.__annotations__["return"] = dict[str, Any]
-        search_function.__name__ = "_" + re.sub(r"[^A-Za-z0-9_]", "_", tool_name)
-
-        # Create the tool function signature string
-        fields = []
-        for name, field in tool_args_schema.model_fields.items():
-            annotation = field.annotation
-            type_name = annotation.__name__ if hasattr(annotation, '__name__') else str(annotation)
-            fields.append(f"{name}: {type_name}")
-        args_str = ", ".join(fields)
-        function_str = f"{tool_name}({args_str}) -> str"
-
-        # Create the tool
-        search_tool_extra_desc = """
-        The response includes metadata about each relevant document, but NOT the text itself.
+        search_tool_extra_desc = tool_description + "\n" + """
+        The response includes metadata about each relevant document.
+        If summarize=True, it also includes a summary of each document.
         """
-        tool = VectaraTool.from_defaults(
-            fn=search_function,
-            name=tool_name,
-            description=function_str + "\n" + tool_description + '\n' + search_tool_extra_desc,
-            fn_schema=tool_args_schema,
-            tool_type=ToolType.QUERY,
+
+        tool = _create_tool_from_dynamic_function(
+            search_function,
+            tool_name,
+            search_tool_extra_desc,
+            base_params,
+            tool_args_schema,
         )
         return tool
 
@@ -597,11 +642,11 @@ class VectaraToolFactory:
             vectara_corpus_key=self.vectara_corpus_key,
             x_source_str="vectara-agentic",
             vectara_base_url=vectara_base_url,
-            vetara_verify_ssl=vectara_verify_ssl,
+            vectara_verify_ssl=vectara_verify_ssl,
         )
 
         # Dynamically generate the RAG function
-        def rag_function(*args, **kwargs) -> ToolOutput:
+        def rag_function(*args: Any, **kwargs: Any) -> ToolOutput:
             """
             Dynamically generated function for RAG query with Vectara.
             """
@@ -721,39 +766,15 @@ class VectaraToolFactory:
             )
             return out
 
-        fields = tool_args_schema.model_fields
-        params = [
-            inspect.Parameter(
-                name=field_name,
-                kind=inspect.Parameter.POSITIONAL_OR_KEYWORD,
-                default=field_info.default,
-                annotation=field_info,
-            )
-            for field_name, field_info in fields.items()
+        base_params = [
+            inspect.Parameter("query", inspect.Parameter.POSITIONAL_OR_KEYWORD, annotation=str),
         ]
-
-        # Create a new signature using the extracted parameters
-        sig = inspect.Signature(params)
-        rag_function.__signature__ = sig
-        rag_function.__annotations__["return"] = dict[str, Any]
-        rag_function.__name__ = "_" + re.sub(r"[^A-Za-z0-9_]", "_", tool_name)
-
-        # Create the tool function signature string
-        fields = []
-        for name, field in tool_args_schema.model_fields.items():
-            annotation = field.annotation
-            type_name = annotation.__name__ if hasattr(annotation, '__name__') else str(annotation)
-            fields.append(f"{name}: {type_name}")
-        args_str = ", ".join(fields)
-        function_str = f"{tool_name}({args_str}) -> str"
-
-        # Create the tool
-        tool = VectaraTool.from_defaults(
-            fn=rag_function,
-            name=tool_name,
-            description=function_str + ". " + tool_description,
-            fn_schema=tool_args_schema,
-            tool_type=ToolType.QUERY,
+        tool = _create_tool_from_dynamic_function(
+            rag_function,
+            tool_name,
+            tool_description,
+            base_params,
+            tool_args_schema,
         )
         return tool
 

{vectara_agentic-0.2.6 → vectara_agentic-0.2.7}/vectara_agentic/types.py

@@ -12,6 +12,7 @@ class AgentType(Enum):
 
     REACT = "REACT"
     OPENAI = "OPENAI"
+    FUNCTION_CALLING = "FUNCTION_CALLING"
     LLMCOMPILER = "LLMCOMPILER"
     LATS = "LATS"
 

{vectara_agentic-0.2.6 → vectara_agentic-0.2.7}/vectara_agentic/utils.py

@@ -5,6 +5,8 @@ Utilities for the Vectara agentic.
 from typing import Tuple, Callable, Optional
 from functools import lru_cache
 from inspect import signature
+import json
+import requests
 
 import tiktoken
 
@@ -90,35 +92,50 @@ def get_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)
+                     strict=True,
+                     max_tokens=max_tokens
+            )
     elif model_provider == ModelProvider.ANTHROPIC:
-        llm = Anthropic(model=model_name, temperature=0)
+        llm = Anthropic(model=model_name, temperature=0, max_tokens=max_tokens)
     elif model_provider == ModelProvider.GEMINI:
         from llama_index.llms.gemini import Gemini
-        llm = Gemini(model=model_name, temperature=0, is_function_calling_model=True)
+        llm = Gemini(
+            model=model_name, temperature=0,
+            is_function_calling_model=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)
+        llm = TogetherLLM(
+            model=model_name, temperature=0,
+            is_function_calling_model=True,
+            max_tokens=max_tokens
+        )
     elif model_provider == ModelProvider.GROQ:
         from llama_index.llms.groq import Groq
-        llm = Groq(model=model_name, temperature=0, is_function_calling_model=True)
+        llm = Groq(
+            model=model_name, temperature=0,
+            is_function_calling_model=True, max_tokens=max_tokens
+        )
     elif model_provider == ModelProvider.FIREWORKS:
         from llama_index.llms.fireworks import Fireworks
-        llm = Fireworks(model=model_name, temperature=0)
+        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)
+        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)
+        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)
+                         api_base=config.private_llm_api_base, api_key=config.private_llm_api_key,
+                         max_tokens=max_tokens)
     else:
         raise ValueError(f"Unknown LLM provider: {model_provider}")
     return llm
@@ -141,3 +158,25 @@ def remove_self_from_signature(func):
     new_sig = sig.replace(parameters=params)
     func.__signature__ = new_sig
     return func
+
+def summarize_vectara_document(corpus_key: str, vectara_api_key, doc_id: str) -> str:
+    """
+    Summarize a document in a Vectara corpus using the Vectara API.
+    """
+    url = f"https://api.vectara.io/v2/corpora/{corpus_key}/documents/{doc_id}/summarize"
+
+    payload = json.dumps({
+        "llm_name": "gpt-4o",
+        "model_parameters": {},
+        "stream_response": False
+    })
+    headers = {
+        'Content-Type': 'application/json',
+        'Accept': 'application/json',
+        'x-api-key': vectara_api_key
+    }
+
+    response = requests.request("POST", url, headers=headers, data=payload, timeout=60)
+    if response.status_code != 200:
+        return f"Vectara Summarization failed with error code {response.status_code}, error={response.text}"
+    return json.loads(response.text)["summary"]

{vectara_agentic-0.2.6 → vectara_agentic-0.2.7/vectara_agentic.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vectara_agentic
-Version: 0.2.6
+Version: 0.2.7
 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

vectara_agentic-0.2.6/tests/test_agent.py

@@ -1,158 +0,0 @@
-import unittest
-from datetime import date
-
-from vectara_agentic.agent import _get_prompt, Agent, AgentType
-from vectara_agentic.agent_config import AgentConfig
-from vectara_agentic.types import ModelProvider, ObserverType
-from vectara_agentic.tools import ToolsFactory
-
-def mult(x, y):
-    return x * y
-
-class TestAgentPackage(unittest.TestCase):
-    def test_get_prompt(self):
-        prompt_template = "{chat_topic} on {today} with {custom_instructions}"
-        topic = "Programming"
-        custom_instructions = "Always do as your mother tells you!"
-        expected_output = (
-            "Programming on "
-            + date.today().strftime("%A, %B %d, %Y")
-            + " with Always do as your mother tells you!"
-        )
-        self.assertEqual(
-            _get_prompt(prompt_template, topic, custom_instructions), expected_output
-        )
-
-    def test_agent_init(self):
-        tools = [ToolsFactory().create_tool(mult)]
-        topic = "AI"
-        custom_instructions = "Always do as your mother tells you!"
-        agent = Agent(tools, topic, custom_instructions)
-        self.assertEqual(agent.agent_type, AgentType.OPENAI)
-        self.assertEqual(agent._topic, topic)
-        self.assertEqual(agent._custom_instructions, custom_instructions)
-
-        # 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"
-            ).response.replace("$", "\\$"),
-            "50",
-        )
-
-    def test_agent_config(self):
-        tools = [ToolsFactory().create_tool(mult)]
-        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._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 ANTHROPIC_API_KEY and TOGETHER_API_KEY in your environment
-        self.assertEqual(
-            agent.chat(
-                "What is 5 times 10. Only give the answer, nothing else"
-            ).response.replace("$", "\\$"),
-            "50",
-        )
-
-    def test_multiturn(self):
-        tools = [ToolsFactory().create_tool(mult)]
-        topic = "AI topic"
-        instructions = "Always do as your father tells you, if your mother agrees!"
-        agent = Agent(
-            tools=tools,
-            topic=topic,
-            custom_instructions=instructions,
-        )
-
-        agent.chat("What is 5 times 10. Only give the answer, nothing else")
-        agent.chat("what is 3 times 7. Only give the answer, nothing else")
-        res = agent.chat("multiply the results of the last two questions. Output only the answer.")
-        self.assertEqual(res.response, "1050")
-
-    def test_from_corpus(self):
-        agent = Agent.from_corpus(
-            tool_name="RAG Tool",
-            vectara_corpus_key="corpus_key",
-            vectara_api_key="api_key",
-            data_description="information",
-            assistant_specialty="question answering",
-        )
-
-        self.assertIsInstance(agent, Agent)
-        self.assertEqual(agent._topic, "question answering")
-
-    def test_serialization(self):
-        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.from_corpus(
-            tool_name="RAG Tool",
-            agent_config=config,
-            vectara_corpus_key="corpus_key",
-            vectara_api_key="api_key",
-            data_description="information",
-            assistant_specialty="question answering",
-        )
-
-        agent_reloaded = agent.loads(agent.dumps())
-        agent_reloaded_again = agent_reloaded.loads(agent_reloaded.dumps())
-
-        self.assertIsInstance(agent_reloaded, Agent)
-        self.assertEqual(agent, agent_reloaded)
-        self.assertEqual(agent.agent_type, agent_reloaded.agent_type)
-
-        self.assertEqual(agent.agent_config.observer, agent_reloaded.agent_config.observer)
-        self.assertEqual(agent.agent_config.main_llm_provider, agent_reloaded.agent_config.main_llm_provider)
-        self.assertEqual(agent.agent_config.tool_llm_provider, agent_reloaded.agent_config.tool_llm_provider)
-
-        self.assertIsInstance(agent_reloaded, Agent)
-        self.assertEqual(agent, agent_reloaded_again)
-        self.assertEqual(agent.agent_type, agent_reloaded_again.agent_type)
-
-        self.assertEqual(agent.agent_config.observer, agent_reloaded_again.agent_config.observer)
-        self.assertEqual(agent.agent_config.main_llm_provider, agent_reloaded_again.agent_config.main_llm_provider)
-        self.assertEqual(agent.agent_config.tool_llm_provider, agent_reloaded_again.agent_config.tool_llm_provider)
-
-    def test_chat_history(self):
-        tools = [ToolsFactory().create_tool(mult)]
-        topic = "AI topic"
-        instructions = "Always do as your father tells you, if your mother agrees!"
-        agent = Agent(
-            tools=tools,
-            topic=topic,
-            custom_instructions=instructions,
-            chat_history=[("What is 5 times 10", "50"), ("What is 3 times 7", "21")]
-        )
-
-        res = agent.chat("multiply the results of the last two questions. Output only the answer.")
-        self.assertEqual(res.response, "1050")
-
-
-if __name__ == "__main__":
-    unittest.main()

vectara_agentic-0.2.6/tests/test_agent_planning.py

@@ -1,46 +0,0 @@
-import unittest
-
-from vectara_agentic.agent import Agent
-from vectara_agentic.agent_config import AgentConfig
-from vectara_agentic.tools import ToolsFactory
-
-def mult(x, y):
-    return x * y
-
-def addition(x, y):
-    return x + y
-
-class TestAgentPlanningPackage(unittest.TestCase):
-
-    def test_no_planning(self):
-        tools = [ToolsFactory().create_tool(mult)]
-        topic = "AI topic"
-        instructions = "Always do as your father tells you, if your mother agrees!"
-        agent = Agent(
-            tools=tools,
-            topic=topic,
-            custom_instructions=instructions,
-            agent_config = AgentConfig()
-        )
-
-        res = agent.chat("If you multiply 5 times 7, then 3 times 2, and add the results - what do you get?")
-        self.assertIn("41", res.response)
-
-    def test_structured_planning(self):
-        tools = [ToolsFactory().create_tool(mult), ToolsFactory().create_tool(addition)]
-        topic = "AI topic"
-        instructions = "Always do as your father tells you, if your mother agrees!"
-        agent = Agent(
-            tools=tools,
-            topic=topic,
-            custom_instructions=instructions,
-            agent_config = AgentConfig(),
-            use_structured_planning = True,
-        )
-
-        res = agent.chat("If you multiply 5 times 7, then 3 times 2, and add the results - what do you get?")
-        self.assertIn("41", res.response)
-
-
-if __name__ == "__main__":
-    unittest.main()

vectara_agentic-0.2.6/tests/test_agent_type.py

@@ -1,83 +0,0 @@
-import unittest
-
-from vectara_agentic.agent import Agent, AgentType
-from vectara_agentic.agent_config import AgentConfig
-from vectara_agentic.tools import ToolsFactory
-from vectara_agentic.types import ModelProvider
-
-import nest_asyncio
-nest_asyncio.apply()
-def mult(x, y):
-    return x * y
-
-
-react_config_1 = AgentConfig(
-    agent_type=AgentType.REACT,
-    main_llm_provider=ModelProvider.ANTHROPIC,
-    main_llm_model_name="claude-3-7-sonnet-20250219",
-    tool_llm_provider=ModelProvider.TOGETHER,
-    tool_llm_model_name="meta-llama/Llama-3.3-70B-Instruct-Turbo",
-)
-
-react_config_2 = AgentConfig(
-    agent_type=AgentType.REACT,
-    main_llm_provider=ModelProvider.GEMINI,
-    tool_llm_provider=ModelProvider.GEMINI,
-)
-
-openai_config = AgentConfig(
-    agent_type=AgentType.OPENAI,
-)
-
-class TestAgentType(unittest.TestCase):
-
-    def test_openai(self):
-        tools = [ToolsFactory().create_tool(mult)]
-        topic = "AI topic"
-        instructions = "Always do as your father tells you, if your mother agrees!"
-        agent = Agent(
-            agent_config=openai_config,
-            tools=tools,
-            topic=topic,
-            custom_instructions=instructions,
-        )
-
-        agent.chat("What is 5 times 10. Only give the answer, nothing else")
-        agent.chat("what is 3 times 7. Only give the answer, nothing else")
-        res = agent.chat("multiply the results of the last two multiplications. Only give the answer, nothing else.")
-        self.assertIn("1050", res.response)
-
-    def test_react_anthropic(self):
-        tools = [ToolsFactory().create_tool(mult)]
-        topic = "AI topic"
-        instructions = "Always do as your father tells you, if your mother agrees!"
-        agent = Agent(
-            agent_config=react_config_1,
-            tools=tools,
-            topic=topic,
-            custom_instructions=instructions,
-        )
-
-        agent.chat("What is 5 times 10. Only give the answer, nothing else")
-        agent.chat("what is 3 times 7. Only give the answer, nothing else")
-        res = agent.chat("multiply the results of the last two multiplications. Only give the answer, nothing else.")
-        self.assertIn("1050", res.response)
-
-    def test_react_gemini(self):
-        tools = [ToolsFactory().create_tool(mult)]
-        topic = "AI topic"
-        instructions = "Always do as your father tells you, if your mother agrees!"
-        agent = Agent(
-            agent_config=react_config_2,
-            tools=tools,
-            topic=topic,
-            custom_instructions=instructions,
-        )
-        agent.chat("What is 5 times 10. Only give the answer, nothing else")
-        agent.chat("what is 3 times 7. Only give the answer, nothing else")
-        res = agent.chat("multiply the results of the last two multiplications. Only give the answer, nothing else.")
-        self.assertIn("1050", res.response)
-
-
-if __name__ == "__main__":
-    unittest.main()