vectara-agentic 0.1.28__tar.gz → 0.2.0__tar.gz

{vectara_agentic-0.1.28/vectara_agentic.egg-info → vectara_agentic-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: vectara_agentic
-Version: 0.1.28
+Version: 0.2.0
 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
@@ -17,7 +17,7 @@ Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: llama-index==0.12.11
-Requires-Dist: llama-index-indices-managed-vectara==0.3.1
+Requires-Dist: llama-index-indices-managed-vectara==0.4.0
 Requires-Dist: llama-index-agent-llm-compiler==0.3.0
 Requires-Dist: llama-index-agent-lats==0.3.0
 Requires-Dist: llama-index-agent-openai==0.4.3

{vectara_agentic-0.1.28 → vectara_agentic-0.2.0}/requirements.txt

@@ -1,5 +1,5 @@
 llama-index==0.12.11
-llama-index-indices-managed-vectara==0.3.1
+llama-index-indices-managed-vectara==0.4.0
 llama-index-agent-llm-compiler==0.3.0
 llama-index-agent-lats==0.3.0
 llama-index-agent-openai==0.4.3

{vectara_agentic-0.1.28 → vectara_agentic-0.2.0}/tests/test_agent.py

@@ -1,9 +1,10 @@
 import unittest
 from datetime import date
 
-from vectara_agentic.agent import _get_prompt, Agent, AgentType, FunctionTool
+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
 
 class TestAgentPackage(unittest.TestCase):
     def test_get_prompt(self):
@@ -23,16 +24,11 @@ class TestAgentPackage(unittest.TestCase):
         def mult(x, y):
             return x * y
 
-        tools = [
-            FunctionTool.from_defaults(
-                fn=mult, name="mult", description="Multiplication functions"
-            )
-        ]
+        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.tools, tools)
         self.assertEqual(agent._topic, topic)
         self.assertEqual(agent._custom_instructions, custom_instructions)
 
@@ -40,7 +36,7 @@ class TestAgentPackage(unittest.TestCase):
         self.assertEqual(
             agent.chat(
                 "What is 5 times 10. Only give the answer, nothing else"
-            ).replace("$", "\\$"),
+            ).response.replace("$", "\\$"),
             "50",
         )
 
@@ -48,11 +44,7 @@ class TestAgentPackage(unittest.TestCase):
         def mult(x, y):
             return x * y
 
-        tools = [
-            FunctionTool.from_defaults(
-                fn=mult, name="mult", description="Multiplication functions"
-            )
-        ]
+        tools = [ToolsFactory().create_tool(mult)]
         topic = "AI topic"
         instructions = "Always do as your father tells you, if your mother agrees!"
         config = AgentConfig(
@@ -70,7 +62,6 @@ class TestAgentPackage(unittest.TestCase):
             custom_instructions=instructions,
             agent_config=config
         )
-        self.assertEqual(agent.tools, tools)
         self.assertEqual(agent._topic, topic)
         self.assertEqual(agent._custom_instructions, instructions)
         self.assertEqual(agent.agent_type, AgentType.REACT)
@@ -78,19 +69,18 @@ class TestAgentPackage(unittest.TestCase):
         self.assertEqual(agent.agent_config.main_llm_provider, ModelProvider.ANTHROPIC)
         self.assertEqual(agent.agent_config.tool_llm_provider, ModelProvider.TOGETHER)
 
-        # To run this test, you must have OPENAI_API_KEY in your environment
+        # 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"
-            ).replace("$", "\\$"),
+            ).response.replace("$", "\\$"),
             "50",
         )
 
     def test_from_corpus(self):
         agent = Agent.from_corpus(
             tool_name="RAG Tool",
-            vectara_customer_id="4584783",
-            vectara_corpus_id="4",
+            vectara_corpus_key="corpus_key",
             vectara_api_key="api_key",
             data_description="information",
             assistant_specialty="question answering",
@@ -102,8 +92,7 @@ class TestAgentPackage(unittest.TestCase):
     def test_serialization(self):
         agent = Agent.from_corpus(
             tool_name="RAG Tool",
-            vectara_customer_id="4584783",
-            vectara_corpus_id="4",
+            vectara_corpus_key="corpus_key",
             vectara_api_key="api_key",
             data_description="information",
             assistant_specialty="question answering",

{vectara_agentic-0.1.28 → vectara_agentic-0.2.0}/tests/test_tools.py

@@ -8,15 +8,13 @@ from llama_index.core.tools import FunctionTool
 
 class TestToolsPackage(unittest.TestCase):
     def test_vectara_tool_factory(self):
-        vectara_customer_id = "4584783"
-        vectara_corpus_id = "4"
+        vectara_corpus_key = "corpus_key"
         vectara_api_key = "api_key"
         vec_factory = VectaraToolFactory(
-            vectara_customer_id, vectara_corpus_id, vectara_api_key
+            vectara_corpus_key, vectara_api_key
         )
 
-        self.assertEqual(vectara_customer_id, vec_factory.vectara_customer_id)
-        self.assertEqual(vectara_corpus_id, vec_factory.vectara_corpus_id)
+        self.assertEqual(vectara_corpus_key, vec_factory.vectara_corpus_key)
         self.assertEqual(vectara_api_key, vec_factory.vectara_api_key)
 
         class QueryToolArgs(BaseModel):
@@ -59,16 +57,14 @@ class TestToolsPackage(unittest.TestCase):
         self.assertEqual(arxiv_tool.metadata.tool_type, ToolType.QUERY)
 
     def test_public_repo(self):
-        vectara_customer_id = "1366999410"
-        vectara_corpus_id = "1"
+        vectara_corpus_key = "vectara-docs_1"
         vectara_api_key = "zqt_UXrBcnI2UXINZkrv4g1tQPhzj02vfdtqYJIDiA"
 
         class QueryToolArgs(BaseModel):
             query: str = Field(description="The user query")
 
         agent = Agent.from_corpus(
-            vectara_customer_id=vectara_customer_id,
-            vectara_corpus_id=vectara_corpus_id,
+            vectara_corpus_key=vectara_corpus_key,
             vectara_api_key=vectara_api_key,
             tool_name="ask_vectara",
             data_description="data from Vectara website",

{vectara_agentic-0.1.28 → vectara_agentic-0.2.0}/vectara_agentic/_callback.py

@@ -146,7 +146,8 @@ class AgentCallbackHandler(BaseCallbackHandler):
         if EventPayload.MESSAGES in payload:
             response = str(payload.get(EventPayload.RESPONSE))
             if response and response not in ["None", "assistant: None"]:
-                self.fn(AgentStatusType.AGENT_UPDATE, response)
+                if self.fn:
+                    self.fn(AgentStatusType.AGENT_UPDATE, response)
         else:
             print(f"No messages or prompt found in payload {payload}")
 
@@ -156,23 +157,27 @@ class AgentCallbackHandler(BaseCallbackHandler):
             tool = payload.get(EventPayload.TOOL)
             if tool:
                 tool_name = tool.name
-                self.fn(
-                    AgentStatusType.TOOL_CALL,
-                    f"Executing '{tool_name}' with arguments: {fcall}",
-                )
+                if self.fn:
+                    self.fn(
+                        AgentStatusType.TOOL_CALL,
+                        f"Executing '{tool_name}' with arguments: {fcall}",
+                    )
         elif EventPayload.FUNCTION_OUTPUT in payload:
             response = str(payload.get(EventPayload.FUNCTION_OUTPUT))
-            self.fn(AgentStatusType.TOOL_OUTPUT, response)
+            if self.fn:
+                self.fn(AgentStatusType.TOOL_OUTPUT, response)
         else:
             print(f"No function call or output found in payload {payload}")
 
     def _handle_agent_step(self, payload: dict) -> None:
         if EventPayload.MESSAGES in payload:
             msg = str(payload.get(EventPayload.MESSAGES))
-            self.fn(AgentStatusType.AGENT_STEP, msg)
+            if self.fn:
+                self.fn(AgentStatusType.AGENT_STEP, msg)
         elif EventPayload.RESPONSE in payload:
             response = str(payload.get(EventPayload.RESPONSE))
-            self.fn(AgentStatusType.AGENT_STEP, response)
+            if self.fn:
+                self.fn(AgentStatusType.AGENT_STEP, response)
         else:
             print(f"No messages or prompt found in payload {payload}")
 
@@ -181,10 +186,11 @@ class AgentCallbackHandler(BaseCallbackHandler):
         if EventPayload.MESSAGES in payload:
             response = str(payload.get(EventPayload.RESPONSE))
             if response and response not in ["None", "assistant: None"]:
-                if inspect.iscoroutinefunction(self.fn):
-                    await self.fn(AgentStatusType.AGENT_UPDATE, response)
-                else:
-                    self.fn(AgentStatusType.AGENT_UPDATE, response)
+                if self.fn:
+                    if inspect.iscoroutinefunction(self.fn):
+                        await self.fn(AgentStatusType.AGENT_UPDATE, response)
+                    else:
+                        self.fn(AgentStatusType.AGENT_UPDATE, response)
         else:
             print(f"No messages or prompt found in payload {payload}")
 
@@ -194,37 +200,41 @@ class AgentCallbackHandler(BaseCallbackHandler):
             tool = payload.get(EventPayload.TOOL)
             if tool:
                 tool_name = tool.name
+                if self.fn:
+                    if inspect.iscoroutinefunction(self.fn):
+                        await self.fn(
+                            AgentStatusType.TOOL_CALL,
+                            f"Executing '{tool_name}' with arguments: {fcall}",
+                        )
+                    else:
+                        self.fn(
+                            AgentStatusType.TOOL_CALL,
+                            f"Executing '{tool_name}' with arguments: {fcall}",
+                        )
+        elif EventPayload.FUNCTION_OUTPUT in payload:
+            if self.fn:
+                response = str(payload.get(EventPayload.FUNCTION_OUTPUT))
                 if inspect.iscoroutinefunction(self.fn):
-                    await self.fn(
-                        AgentStatusType.TOOL_CALL,
-                        f"Executing '{tool_name}' with arguments: {fcall}",
-                    )
+                    await self.fn(AgentStatusType.TOOL_OUTPUT, response)
                 else:
-                    self.fn(
-                        AgentStatusType.TOOL_CALL,
-                        f"Executing '{tool_name}' with arguments: {fcall}",
-                    )
-        elif EventPayload.FUNCTION_OUTPUT in payload:
-            response = str(payload.get(EventPayload.FUNCTION_OUTPUT))
-            if inspect.iscoroutinefunction(self.fn):
-                await self.fn(AgentStatusType.TOOL_OUTPUT, response)
-            else:
-                self.fn(AgentStatusType.TOOL_OUTPUT, response)
+                    self.fn(AgentStatusType.TOOL_OUTPUT, response)
         else:
             print(f"No function call or output found in payload {payload}")
 
     async def _ahandle_agent_step(self, payload: dict) -> None:
         if EventPayload.MESSAGES in payload:
-            msg = str(payload.get(EventPayload.MESSAGES))
-            if inspect.iscoroutinefunction(self.fn):
-                await self.fn(AgentStatusType.AGENT_STEP, msg)
-            else:
-                self.fn(AgentStatusType.AGENT_STEP, msg)
+            if self.fn:
+                msg = str(payload.get(EventPayload.MESSAGES))
+                if inspect.iscoroutinefunction(self.fn):
+                    await self.fn(AgentStatusType.AGENT_STEP, msg)
+                else:
+                    self.fn(AgentStatusType.AGENT_STEP, msg)
         elif EventPayload.RESPONSE in payload:
-            response = str(payload.get(EventPayload.RESPONSE))
-            if inspect.iscoroutinefunction(self.fn):
-                await self.fn(AgentStatusType.AGENT_STEP, response)
-            else:
-                self.fn(AgentStatusType.AGENT_STEP, response)
+            if self.fn:
+                response = str(payload.get(EventPayload.RESPONSE))
+                if inspect.iscoroutinefunction(self.fn):
+                    await self.fn(AgentStatusType.AGENT_STEP, response)
+                else:
+                    self.fn(AgentStatusType.AGENT_STEP, response)
         else:
             print(f"No messages or prompt found in payload {payload}")

{vectara_agentic-0.1.28 → vectara_agentic-0.2.0}/vectara_agentic/_version.py

@@ -1,4 +1,4 @@
 """
 Define the version of the package.
 """
-__version__ = "0.1.28"
+__version__ = "0.2.0"

{vectara_agentic-0.1.28 → vectara_agentic-0.2.0}/vectara_agentic/agent.py

@@ -294,28 +294,42 @@ class Agent:
         tool_name: str,
         data_description: str,
         assistant_specialty: str,
-        vectara_customer_id: str = str(os.environ.get("VECTARA_CUSTOMER_ID", "")),
-        vectara_corpus_id: str = str(os.environ.get("VECTARA_CORPUS_ID", "")),
+        vectara_corpus_key: str = str(os.environ.get("VECTARA_CORPUS_KEY", "")),
         vectara_api_key: str = str(os.environ.get("VECTARA_API_KEY", "")),
         agent_progress_callback: Optional[Callable[[AgentStatusType, str], None]] = None,
         query_logging_callback: Optional[Callable[[str, str], None]] = None,
         verbose: bool = False,
         vectara_filter_fields: list[dict] = [],
+        vectara_offset: int = 0,
         vectara_lambda_val: float = 0.005,
-        vectara_reranker: str = "mmr",
+        vectara_semantics: str = "default",
+        vectara_custom_dimensions: Dict = {},
+        vectara_reranker: str = "slingshot",
         vectara_rerank_k: int = 50,
+        vectara_rerank_limit: Optional[int] = None,
+        vectara_rerank_cutoff: Optional[float] = None,
+        vectara_diversity_bias: float = 0.2,
+        vectara_udf_expression: str = None,
+        vectara_rerank_chain: List[Dict] = None,
         vectara_n_sentences_before: int = 2,
         vectara_n_sentences_after: int = 2,
         vectara_summary_num_results: int = 10,
-        vectara_summarizer: str = "vectara-summary-ext-24-05-sml",
+        vectara_summarizer: str = "vectara-summary-ext-24-05-med-omni",
+        vectara_summary_response_language: str = "eng",
+        vectara_summary_prompt_text: Optional[str] = None,
+        vectara_max_response_chars: Optional[int] = None,
+        vectara_max_tokens: Optional[int] = None,
+        vectara_temperature: Optional[float] = None,
+        vectara_frequency_penalty: Optional[float] = None,
+        vectara_presence_penalty: Optional[float] = None,
+        vectara_save_history: bool = False,
     ) -> "Agent":
         """
         Create an agent from a single Vectara corpus
 
         Args:
             tool_name (str): The name of Vectara tool used by the agent
-            vectara_customer_id (str): The Vectara customer ID.
-            vectara_corpus_id (str): The Vectara corpus ID (or comma separated list of IDs).
+            vectara_corpus_key (str): The Vectara corpus key (or comma separated list of keys).
             vectara_api_key (str): The Vectara API key.
             agent_progress_callback (Callable): A callback function the code calls on any agent updates.
             query_logging_callback (Callable): A callback function the code calls upon completion of a query
@@ -324,21 +338,41 @@ class Agent:
             verbose (bool, optional): Whether to print verbose output.
             vectara_filter_fields (List[dict], optional): The filterable attributes
                 (each dict maps field name to Tuple[type, description]).
-            vectara_lambda_val (float, optional): The lambda value for Vectara hybrid search.
-            vectara_reranker (str, optional): The Vectara reranker name (default "mmr")
+            vectara_offset (int, optional): Number of results to skip.
+            vectara_lambda_val (float, optional): Lambda value for Vectara hybrid search.
+            vectara_semantics: (str, optional): Indicates whether the query is intended as a query or response.
+            vectara_custom_dimensions: (Dict, optional): Custom dimensions for the query.
+            vectara_reranker (str, optional): The Vectara reranker name (default "slingshot")
             vectara_rerank_k (int, optional): The number of results to use with reranking.
+            vetara_rerank_limit: (int, optional): The maximum number of results to return after reranking.
+            vectara_rerank_cutoff: (float, optional): The minimum score threshold for results to include after
+                reranking.
+            vectara_diversity_bias (float, optional): The MMR diversity bias.
+            vectara_udf_expression (str, optional): The user defined expression for reranking results.
+            vectara_rerank_chain (List[Dict], optional): A list of Vectara rerankers to be applied sequentially.
             vectara_n_sentences_before (int, optional): The number of sentences before the matching text
             vectara_n_sentences_after (int, optional): The number of sentences after the matching text.
             vectara_summary_num_results (int, optional): The number of results to use in summarization.
             vectara_summarizer (str, optional): The Vectara summarizer name.
+            vectara_summary_response_language (str, optional): The response language for the Vectara summary.
+            vectara_summary_prompt_text (str, optional): The custom prompt, using appropriate prompt variables and
+                functions.
+            vectara_max_response_chars (int, optional): The desired maximum number of characters for the generated
+                summary.
+            vectara_max_tokens (int, optional): The maximum number of tokens to be returned by the LLM.
+            vectara_temperature (float, optional): The sampling temperature; higher values lead to more randomness.
+            vectara_frequency_penalty (float, optional): How much to penalize repeating tokens in the response,
+                higher values reducing likelihood of repeating the same line.
+            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.
 
         Returns:
             Agent: An instance of the Agent class.
         """
         vec_factory = VectaraToolFactory(
             vectara_api_key=vectara_api_key,
-            vectara_customer_id=vectara_customer_id,
-            vectara_corpus_id=vectara_corpus_id,
+            vectara_corpus_key=vectara_corpus_key,
         )
         field_definitions = {}
         field_definitions["query"] = (str, Field(description="The user query"))  # type: ignore
@@ -350,7 +384,7 @@ class Agent:
         query_args = create_model("QueryArgs", **field_definitions)  # type: ignore
 
         vectara_tool = vec_factory.create_rag_tool(
-            tool_name=tool_name or f"vectara_{vectara_corpus_id}",
+            tool_name=tool_name or f"vectara_{vectara_corpus_key}",
             tool_description=f"""
             Given a user query,
             returns a response (str) to a user question about {data_description}.
@@ -358,13 +392,28 @@ class Agent:
             tool_args_schema=query_args,
             reranker=vectara_reranker,
             rerank_k=vectara_rerank_k,
+            rerank_limit=vectara_rerank_limit,
+            rerank_cutoff=vectara_rerank_cutoff,
+            mmr_diversity_bias=vectara_diversity_bias,
+            udf_expression=vectara_udf_expression,
+            rerank_chain=vectara_rerank_chain,
             n_sentences_before=vectara_n_sentences_before,
             n_sentences_after=vectara_n_sentences_after,
+            offset=vectara_offset,
             lambda_val=vectara_lambda_val,
+            semantics=vectara_semantics,
+            custom_dimensions=vectara_custom_dimensions,
             summary_num_results=vectara_summary_num_results,
             vectara_summarizer=vectara_summarizer,
+            summary_response_lang=vectara_summary_response_language,
+            vectara_prompt_text=vectara_summary_prompt_text,
+            max_response_chars=vectara_max_response_chars,
+            max_tokens=vectara_max_tokens,
+            temperature=vectara_temperature,
+            frequency_penalty=vectara_frequency_penalty,
+            presence_penalty=vectara_presence_penalty,
+            save_history=vectara_save_history,
             include_citations=True,
-            verbose=verbose,
         )
 
         assistant_instructions = f"""

{vectara_agentic-0.1.28 → vectara_agentic-0.2.0}/vectara_agentic/db_tools.py

@@ -74,7 +74,7 @@ class DBLoadUniqueValues(DBTool):
     """
     A tool to list all unique values for each column in a set of columns of a database table.
     """
-    def __call__(self, table_name: str, columns: list[str], num_vals: int = 200) -> dict:
+    def __call__(self, table_name: str, columns: list[str], num_vals: int = 200) -> Any:
         """
         Fetches the first num_vals unique values from the specified columns of the database table.
 
@@ -84,7 +84,7 @@ class DBLoadUniqueValues(DBTool):
             num_vals (int): The number of unique values to fetch for each column. Default is 200.
 
         Returns:
-            dict: A dictionary containing the unique values for each column.
+            Any: the result of the database query
         """
         res = {}
         try:

{vectara_agentic-0.1.28 → vectara_agentic-0.2.0}/vectara_agentic/tools.py

@@ -7,7 +7,7 @@ import re
 import importlib
 import os
 
-from typing import Callable, List, Dict, Any, Optional, Type
+from typing import Callable, List, Dict, Any, Optional, Union, Type
 from pydantic import BaseModel, Field
 from pydantic_core import PydanticUndefined
 
@@ -261,21 +261,18 @@ class VectaraToolFactory:
 
     def __init__(
         self,
-        vectara_customer_id: str = str(os.environ.get("VECTARA_CUSTOMER_ID", "")),
-        vectara_corpus_id: str = str(os.environ.get("VECTARA_CORPUS_ID", "")),
+        vectara_corpus_key: str = str(os.environ.get("VECTARA_CORPUS_KEY", "")),
         vectara_api_key: str = str(os.environ.get("VECTARA_API_KEY", "")),
     ) -> None:
         """
         Initialize the VectaraToolFactory
         Args:
-            vectara_customer_id (str): The Vectara customer ID.
-            vectara_corpus_id (str): The Vectara corpus ID (or comma separated list of IDs).
+            vectara_corpus_key (str): The Vectara corpus key (or comma separated list of keys).
             vectara_api_key (str): The Vectara API key.
         """
-        self.vectara_customer_id = vectara_customer_id
-        self.vectara_corpus_id = vectara_corpus_id
+        self.vectara_corpus_key = vectara_corpus_key
         self.vectara_api_key = vectara_api_key
-        self.num_corpora = len(vectara_corpus_id.split(","))
+        self.num_corpora = len(vectara_corpus_key.split(","))
 
     def create_search_tool(
         self,
@@ -284,12 +281,20 @@ class VectaraToolFactory:
         tool_args_schema: type[BaseModel],
         tool_args_type: Dict[str, str] = {},
         fixed_filter: str = "",
-        lambda_val: float = 0.005,
-        reranker: str = "mmr",
+        lambda_val: Union[List[float], float] = 0.005,
+        semantics: Union[List[str] | str] = "default",
+        custom_dimensions: Union[List[Dict], Dict] = {},
+        offset: int = 0,
+        n_sentences_before: int = 2,
+        n_sentences_after: int = 2,
+        reranker: str = "slingshot",
         rerank_k: int = 50,
+        rerank_limit: Optional[int] = None,
+        rerank_cutoff: Optional[float] = None,
         mmr_diversity_bias: float = 0.2,
         udf_expression: str = None,
         rerank_chain: List[Dict] = None,
+        save_history: bool = False,
         verbose: bool = False,
     ) -> VectaraTool:
         """
@@ -301,9 +306,18 @@ class VectaraToolFactory:
             tool_args_schema (BaseModel): The schema for the tool arguments.
             tool_args_type (Dict[str, str], optional): The type of each argument (doc or part).
             fixed_filter (str, optional): A fixed Vectara filter condition to apply to all queries.
-            lambda_val (float, optional): Lambda value for the Vectara query.
+            lambda_val (Union[List[float] | float], optional): Lambda value (or list of values for each corpora)
+                for the Vectara query, when using hybrid search.
+            semantics (Union[List[str], str], optional): Indicates whether the query is intended as a query or response.
+                Include list if using multiple corpora specifying the query type for each corpus.
+            custom_dimensions (Union[List[Dict] | Dict], optional): Custom dimensions for the query (for each corpora).
+            offset (int, optional): Number of results to skip.
+            n_sentences_before (int, optional): Number of sentences before the matching document part.
+            n_sentences_after (int, optional): Number of sentences after the matching document part.
             reranker (str, optional): The reranker mode.
             rerank_k (int, optional): Number of top-k documents for reranking.
+            rerank_limit (int, optional): Maximum number of results to return after reranking.
+            rerank_cutoff (float, optional): Minimum score threshold for results to include after reranking.
             mmr_diversity_bias (float, optional): MMR diversity bias.
             udf_expression (str, optional): the user defined expression for reranking results.
             rerank_chain (List[Dict], optional): A list of rerankers to be applied sequentially.
@@ -311,6 +325,7 @@ class VectaraToolFactory:
                 and any other parameters (e.g. "limit" or "cutoff" for any type,
                 "diversity_bias" for mmr, and "user_function" for udf).
                 If using slingshot/multilingual_reranker_v1, it must be first in the list.
+            save_history (bool, optional): Whether to save the query in history.
             verbose (bool, optional): Whether to print verbose output.
 
         Returns:
@@ -319,8 +334,7 @@ class VectaraToolFactory:
 
         vectara = VectaraIndex(
             vectara_api_key=self.vectara_api_key,
-            vectara_customer_id=self.vectara_customer_id,
-            vectara_corpus_id=self.vectara_corpus_id,
+            vectara_corpus_key=self.vectara_corpus_key,
             x_source_str="vectara-agentic",
         )
 
@@ -352,11 +366,19 @@ class VectaraToolFactory:
                 similarity_top_k=top_k,
                 reranker=reranker,
                 rerank_k=rerank_k if rerank_k * self.num_corpora <= 100 else int(100 / self.num_corpora),
+                rerank_limit=rerank_limit,
+                rerank_cutoff=rerank_cutoff,
                 mmr_diversity_bias=mmr_diversity_bias,
                 udf_expression=udf_expression,
                 rerank_chain=rerank_chain,
                 lambda_val=lambda_val,
+                semantics=semantics,
+                custom_dimensions=custom_dimensions,
+                offset=offset,
                 filter=filter_string,
+                n_sentences_before=n_sentences_before,
+                n_sentences_after=n_sentences_after,
+                save_history=save_history,
                 x_source_str="vectara-agentic",
                 verbose=verbose,
             )
@@ -428,19 +450,30 @@ class VectaraToolFactory:
         tool_args_schema: type[BaseModel],
         tool_args_type: Dict[str, dict] = {},
         fixed_filter: str = "",
-        vectara_summarizer: str = "vectara-summary-ext-24-05-sml",
+        vectara_summarizer: str = "vectara-summary-ext-24-05-med-omni",
         vectara_prompt_text: str = None,
         summary_num_results: int = 5,
         summary_response_lang: str = "eng",
         n_sentences_before: int = 2,
         n_sentences_after: int = 2,
-        lambda_val: float = 0.005,
-        reranker: str = "mmr",
+        offset: int = 0,
+        lambda_val: Union[List[float], float] = 0.005,
+        semantics: Union[List[str] | str] = "default",
+        custom_dimensions: Union[List[Dict], Dict] = {},
+        reranker: str = "slingshot",
         rerank_k: int = 50,
+        rerank_limit: Optional[int] = None,
+        rerank_cutoff: Optional[float] = None,
         mmr_diversity_bias: float = 0.2,
         udf_expression: str = None,
         rerank_chain: List[Dict] = None,
+        max_response_chars: Optional[int] = None,
+        max_tokens: Optional[int] = None,
+        temperature: Optional[float] = None,
+        frequency_penalty: Optional[float] = None,
+        presence_penalty: Optional[float] = None,
         include_citations: bool = True,
+        save_history: bool = False,
         fcs_threshold: float = 0.0,
         verbose: bool = False,
     ) -> VectaraTool:
@@ -460,21 +493,37 @@ class VectaraToolFactory:
             vectara_prompt_text (str, optional): The prompt text for the Vectara summarizer.
             summary_num_results (int, optional): The number of summary results.
             summary_response_lang (str, optional): The response language for the summary.
+            summary_prompt_text (str, optional): The custom prompt, using appropriate prompt variables and functions.
             n_sentences_before (int, optional): Number of sentences before the summary.
             n_sentences_after (int, optional): Number of sentences after the summary.
-            lambda_val (float, optional): Lambda value for the Vectara query.
+            offset (int, optional): Number of results to skip.
+            lambda_val (Union[List[float] | float], optional): Lambda value (or list of values for each corpora)
+                for the Vectara query, when using hybrid search.
+            semantics (Union[List[str], str], optional): Indicates whether the query is intended as a query or response.
+                Include list if using multiple corpora specifying the query type for each corpus.
+            custom_dimensions (Union[List[Dict] | Dict], optional): Custom dimensions for the query (for each corpora).
             reranker (str, optional): The reranker mode.
             rerank_k (int, optional): Number of top-k documents for reranking.
+            rerank_limit (int, optional): Maximum number of results to return after reranking.
+            rerank_cutoff (float, optional): Minimum score threshold for results to include after reranking.
             mmr_diversity_bias (float, optional): MMR diversity bias.
-            udf_expression (str, optional): the user defined expression for reranking results.
+            udf_expression (str, optional): The user defined expression for reranking results.
             rerank_chain (List[Dict], optional): A list of rerankers to be applied sequentially.
                 Each dictionary should specify the "type" of reranker (mmr, slingshot, udf)
                 and any other parameters (e.g. "limit" or "cutoff" for any type,
                 "diversity_bias" for mmr, and "user_function" for udf).
                 If using slingshot/multilingual_reranker_v1, it must be first in the list.
+            max_response_chars (int, optional): The desired maximum number of characters for the generated summary.
+            max_tokens (int, optional): The maximum number of tokens to be returned by the LLM.
+            temperature (float, optional): The sampling temperature; higher values lead to more randomness.
+            frequency_penalty (float, optional): How much to penalize repeating tokens in the response,
+                higher values reducing likelihood of repeating the same line.
+            presence_penalty (float, optional): How much to penalize repeating tokens in the response,
+                higher values increasing the diversity of topics.
             include_citations (bool, optional): Whether to include citations in the response.
                 If True, uses markdown vectara citations that requires the Vectara scale plan.
-            fcs_threshold (float, optional): a threshold for factual consistency.
+            save_history (bool, optional): Whether to save the query in history.
+            fcs_threshold (float, optional): A threshold for factual consistency.
                 If set above 0, the tool notifies the calling agent that it "cannot respond" if FCS is too low.
             verbose (bool, optional): Whether to print verbose output.
 
@@ -484,8 +533,7 @@ class VectaraToolFactory:
 
         vectara = VectaraIndex(
             vectara_api_key=self.vectara_api_key,
-            vectara_customer_id=self.vectara_customer_id,
-            vectara_corpus_id=self.vectara_corpus_id,
+            vectara_corpus_key=self.vectara_corpus_key,
             x_source_str="vectara-agentic",
         )
 
@@ -520,15 +568,26 @@ class VectaraToolFactory:
                 prompt_text=vectara_prompt_text,
                 reranker=reranker,
                 rerank_k=rerank_k if rerank_k * self.num_corpora <= 100 else int(100 / self.num_corpora),
+                rerank_limit=rerank_limit,
+                rerank_cutoff=rerank_cutoff,
                 mmr_diversity_bias=mmr_diversity_bias,
                 udf_expression=udf_expression,
                 rerank_chain=rerank_chain,
                 n_sentence_before=n_sentences_before,
                 n_sentence_after=n_sentences_after,
+                offset=offset,
                 lambda_val=lambda_val,
+                semantics=semantics,
+                custom_dimensions=custom_dimensions,
                 filter=filter_string,
-                citations_style="MARKDOWN" if include_citations else None,
+                max_response_chars=max_response_chars,
+                max_tokens=max_tokens,
+                temperature=temperature,
+                frequency_penalty=frequency_penalty,
+                presence_penalty=presence_penalty,
+                citations_style="markdown" if include_citations else None,
                 citations_url_pattern="{doc.url}" if include_citations else None,
+                save_history=save_history,
                 x_source_str="vectara-agentic",
                 verbose=verbose,
             )
@@ -571,7 +630,7 @@ class VectaraToolFactory:
                     + ".\n"
                 )
             fcs = response.metadata["fcs"] if "fcs" in response.metadata else 0.0
-            if fcs < fcs_threshold:
+            if fcs and fcs < fcs_threshold:
                 msg = f"Could not answer the query due to suspected hallucination (fcs={fcs})."
                 return ToolOutput(
                     tool_name=rag_function.__name__,

{vectara_agentic-0.1.28 → vectara_agentic-0.2.0}/vectara_agentic/types.py

@@ -47,8 +47,8 @@ class AgentStatusType(Enum):
 class LLMRole(Enum):
     """Enumeration for different types of LLM roles."""
 
-    MAIN: str = "MAIN"
-    TOOL: str = "TOOL"
+    MAIN = "MAIN"
+    TOOL = "TOOL"
 
 
 class ToolType(Enum):

{vectara_agentic-0.1.28 → vectara_agentic-0.2.0/vectara_agentic.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: vectara_agentic
-Version: 0.1.28
+Version: 0.2.0
 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
@@ -17,7 +17,7 @@ Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: llama-index==0.12.11
-Requires-Dist: llama-index-indices-managed-vectara==0.3.1
+Requires-Dist: llama-index-indices-managed-vectara==0.4.0
 Requires-Dist: llama-index-agent-llm-compiler==0.3.0
 Requires-Dist: llama-index-agent-lats==0.3.0
 Requires-Dist: llama-index-agent-openai==0.4.3

{vectara_agentic-0.1.28 → vectara_agentic-0.2.0}/vectara_agentic.egg-info/requires.txt

@@ -1,5 +1,5 @@
 llama-index==0.12.11
-llama-index-indices-managed-vectara==0.3.1
+llama-index-indices-managed-vectara==0.4.0
 llama-index-agent-llm-compiler==0.3.0
 llama-index-agent-lats==0.3.0
 llama-index-agent-openai==0.4.3