vectara-agentic 0.1.4__py3-none-any.whl → 0.1.5__py3-none-any.whl

vectara_agentic/agent.py

@@ -7,25 +7,28 @@ import os
 from datetime import date
 
 from retrying import retry
+from pydantic import Field, create_model
+
 
 from llama_index.core.tools import FunctionTool
 from llama_index.core.agent import ReActAgent
 from llama_index.core.agent.react.formatter import ReActChatFormatter
-from llama_index.core.callbacks import CallbackManager
+from llama_index.core.callbacks import CallbackManager, TokenCountingHandler
 from llama_index.agent.openai import OpenAIAgent
 from llama_index.core.memory import ChatMemoryBuffer
 
 from dotenv import load_dotenv
 
 from .types import AgentType, AgentStatusType, LLMRole
-from .utils import get_llm
+from .utils import get_llm, get_tokenizer_for_model
 from ._prompts import REACT_PROMPT_TEMPLATE, GENERAL_PROMPT_TEMPLATE
 from ._callback import AgentCallbackHandler
+from .tools import VectaraToolFactory
 
 load_dotenv(override=True)
 
 
-def get_prompt(prompt_template: str, topic: str, custom_instructions: str):
+def _get_prompt(prompt_template: str, topic: str, custom_instructions: str):
     """
     Generate a prompt by replacing placeholders with topic and date.
 
@@ -44,7 +47,7 @@ def get_prompt(prompt_template: str, topic: str, custom_instructions: str):
     )
 
 
-def retry_if_exception(exception):
+def _retry_if_exception(exception):
     # Define the condition to retry on certain exceptions
     return isinstance(
         exception, (TimeoutError)
@@ -61,6 +64,7 @@ class Agent:
         tools: list[FunctionTool],
         topic: str = "general",
         custom_instructions: str = "",
+        verbose: bool = True,
         update_func: Optional[Callable[[AgentStatusType, str], None]] = None,
     ):
         """
@@ -79,28 +83,38 @@ class Agent:
         self._custom_instructions = custom_instructions
         self._topic = topic
 
-        callback_manager = CallbackManager([AgentCallbackHandler(update_func)])  # type: ignore
+        main_tok = get_tokenizer_for_model(role=LLMRole.MAIN)
+        self.main_token_counter = TokenCountingHandler(tokenizer = main_tok) if main_tok else None
+        tool_tok = get_tokenizer_for_model(role=LLMRole.TOOL)
+        self.tool_token_counter = TokenCountingHandler(tokenizer = tool_tok) if tool_tok else None
+        
+        callbacks = [AgentCallbackHandler(update_func)]
+        if self.main_token_counter:
+            callbacks.append(self.main_token_counter)
+        if self.tool_token_counter:
+            callbacks.append(self.tool_token_counter)
+        callback_manager = CallbackManager(callbacks)   # type: ignore
         self.llm.callback_manager = callback_manager
 
         memory = ChatMemoryBuffer.from_defaults(token_limit=128000)
         if self.agent_type == AgentType.REACT:
-            prompt = get_prompt(REACT_PROMPT_TEMPLATE, topic, custom_instructions)
+            prompt = _get_prompt(REACT_PROMPT_TEMPLATE, topic, custom_instructions)
             self.agent = ReActAgent.from_tools(
                 tools=tools,
                 llm=self.llm,
                 memory=memory,
-                verbose=True,
+                verbose=verbose,
                 react_chat_formatter=ReActChatFormatter(system_header=prompt),
                 max_iterations=20,
                 callable_manager=callback_manager,
             )
         elif self.agent_type == AgentType.OPENAI:
-            prompt = get_prompt(GENERAL_PROMPT_TEMPLATE, topic, custom_instructions)
+            prompt = _get_prompt(GENERAL_PROMPT_TEMPLATE, topic, custom_instructions)
             self.agent = OpenAIAgent.from_tools(
                 tools=tools,
                 llm=self.llm,
                 memory=memory,
-                verbose=True,
+                verbose=verbose,
                 callable_manager=callback_manager,
                 max_function_calls=10,
                 system_prompt=prompt,
@@ -114,6 +128,7 @@ class Agent:
         tools: List[FunctionTool],
         topic: str = "general",
         custom_instructions: str = "",
+        verbose: bool = True,
         update_func: Optional[Callable[[AgentStatusType, str], None]] = None,
     ) -> "Agent":
         """
@@ -129,7 +144,91 @@ class Agent:
         Returns:
             Agent: An instance of the Agent class.
         """
-        return cls(tools, topic, custom_instructions, update_func)
+        return cls(tools, topic, custom_instructions, verbose, update_func)
+
+
+    @classmethod
+    def from_corpus(
+        cls,
+        vectara_customer_id: str,
+        vectara_corpus_id: str,
+        vectara_api_key: str,
+        data_description: str,
+        assistant_specialty: str,
+        verbose: bool = False,
+        vectara_filter_fields: list[dict] = [],
+        vectara_lambda_val: float = 0.005,
+        vectara_reranker: str = "mmr",
+        vectara_rerank_k: int = 50,
+        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",
+    ) -> "Agent":
+        """
+        Create an agent from a single Vectara corpus
+
+        Args:
+            name (str): The name .
+            vectara_customer_id (str): The Vectara customer ID.
+            vectara_corpus_id (str): The Vectara corpus ID.
+            vectara_api_key (str): The Vectara API key.
+            data_description (str): The description of the data.
+            assistant_specialty (str): The specialty of the assistant.
+            verbose (bool): Whether to print verbose output.
+            vectara_filter_fields (List[dict]): The filterable attributes (each dict includes name, type, and description).
+            vectara_lambda_val (float): The lambda value for Vectara hybrid search.
+            vectara_reranker (str): The Vectara reranker name (default "mmr")
+            vectara_rerank_k (int): The number of results to use with reranking.
+            vectara_n_sentences_before (int): The number of sentences before the matching text
+            vectara_n_sentences_after (int): The number of sentences after the matching text.
+            vectara_summary_num_results (int): The number of results to use in summarization.
+            vectara_summarizer (str): The Vectara summarizer name.
+
+        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)        
+        QueryArgs = create_model(
+            "QueryArgs",
+            query=(str, Field(description="The user query")),
+            **{
+                field['name']: (field['type'], Field(description=field['description'], default=None))
+                for field in vectara_filter_fields
+            }
+        )
+
+        vectara_tool = vec_factory.create_rag_tool(
+            tool_name = f"vectara_{vectara_corpus_id}",
+            tool_description = f"""
+            Given a user query,
+            returns a response (str) to a user question about {data_description}.
+            """,
+            tool_args_schema = QueryArgs,
+            reranker = vectara_reranker, rerank_k = vectara_rerank_k, 
+            n_sentences_before = vectara_n_sentences_before, 
+            n_sentences_after = vectara_n_sentences_after, 
+            lambda_val = vectara_lambda_val,
+            summary_num_results = vectara_summary_num_results,
+            vectara_summarizer = vectara_summarizer,
+            include_citations = False,
+        )
+
+        assistant_instructions = f"""
+        - You are a helpful {assistant_specialty} assistant.
+        - You can answer questions about {data_description}.
+        - Never discuss politics, and always respond politely.
+        """
+
+        return cls(
+            tools=[vectara_tool], 
+            topic=assistant_specialty, 
+            custom_instructions=assistant_instructions, 
+            verbose=verbose,
+            update_func=None
+        )
 
     def report(self) -> str:
         """
@@ -147,8 +246,20 @@ class Agent:
         print(f"Agent LLM = {get_llm(LLMRole.MAIN).model}")
         print(f"Tool LLM = {get_llm(LLMRole.TOOL).model}")
 
+    def token_counts(self) -> dict:
+        """
+        Get the token counts for the agent and tools.
+
+        Returns:
+            dict: The token counts for the agent and tools.
+        """
+        return {
+            "main token count": self.main_token_counter.total_llm_token_count if self.main_token_counter else -1,
+            "tool token count": self.tool_token_counter.total_llm_token_count if self.tool_token_counter else -1,
+        }
+
     @retry(
-        retry_on_exception=retry_if_exception,
+        retry_on_exception=_retry_if_exception,
         stop_max_attempt_number=3,
         wait_fixed=2000,
     )

vectara_agentic/tools.py

@@ -13,6 +13,8 @@ from llama_index.core.tools import FunctionTool
 from llama_index.core.base.response.schema import Response
 from llama_index.indices.managed.vectara import VectaraIndex
 from llama_index.core.utilities.sql_wrapper import SQLDatabase
+from llama_index.core.tools.types import AsyncBaseTool, ToolMetadata
+
 
 from .types import ToolType
 from .tools_catalog import (
@@ -49,7 +51,7 @@ LI_packages = {
 }
 
 
-class VectaraTool:
+class VectaraTool(AsyncBaseTool):
     """
     A wrapper of FunctionTool class for Vectara tools, adding the tool_type attribute.
     """
@@ -63,6 +65,26 @@ class VectaraTool:
 
     def __call__(self, *args, **kwargs):
         return self.function_tool(*args, **kwargs)
+        
+    def call(self, *args, **kwargs):
+        return self.function_tool.call(*args, **kwargs)
+    
+    def acall(self, *args, **kwargs):
+        return self.function_tool.acall(*args, **kwargs)
+    
+    @property
+    def metadata(self) -> ToolMetadata:
+        """Metadata."""
+        return self.function_tool.metadata
+
+    def __repr__(self):
+        repr_str = f"""
+            Name: {self.function_tool._metadata.name}
+            Tool Type: {self.tool_type}
+            Description: {self.function_tool._metadata.description}
+            Schema: {inspect.signature(self.function_tool._metadata.fn_schema)}
+        """
+        return repr_str
 
 
 class VectaraToolFactory:
@@ -76,6 +98,13 @@ class VectaraToolFactory:
         vectara_corpus_id: str,
         vectara_api_key: str,
     ) -> None:
+        """
+        Initialize the VectaraToolFactory
+        Args:
+            vectara_customer_id (str): The Vectara customer ID.
+            vectara_corpus_id (str): The Vectara corpus ID.
+            vectara_api_key (str): The Vectara API key.
+        """
         self.vectara_customer_id = vectara_customer_id
         self.vectara_corpus_id = vectara_corpus_id
         self.vectara_api_key = vectara_api_key
@@ -100,7 +129,6 @@ class VectaraToolFactory:
         Creates a RAG (Retrieve and Generate) tool.
 
         Args:
-
             tool_name (str): The name of the tool.
             tool_description (str): The description of the tool.
             tool_args_schema (BaseModel): The schema for the tool arguments.
@@ -125,7 +153,7 @@ class VectaraToolFactory:
             vectara_corpus_id=self.vectara_corpus_id,
         )
 
-        def build_filter_string(kwargs):
+        def _build_filter_string(kwargs):
             filter_parts = []
             for key, value in kwargs.items():
                 if value:
@@ -147,7 +175,7 @@ class VectaraToolFactory:
             kwargs = bound_args.arguments
 
             query = kwargs.pop("query")
-            filter_string = build_filter_string(kwargs)
+            filter_string = _build_filter_string(kwargs)
 
             vectara_query_engine = vectara.as_query_engine(
                 summary_enabled=True,
@@ -189,65 +217,28 @@ class VectaraToolFactory:
             }
             return res
 
-        # Create signature for rag_function based on tool_args_schema
-        parameters = []
-        for name, param in tool_args_schema.__fields__.items():
-            default = inspect.Parameter.empty
-            if param.default is not None:
-                default = param.default
-            elif param.default_factory is not None:
-                default = param.default_factory()
-
-            parameters.append(
-                inspect.Parameter(
-                    name,
-                    inspect.Parameter.POSITIONAL_OR_KEYWORD,
-                    default=default,
-                    annotation=param.type_ if param.required else Optional[param.type_],
-                )
-            )
-        if (
-            "query" not in tool_args_schema.__fields__
-        ):  # Add 'query' parameter if it's not already in the schema
-            parameters.append(
-                inspect.Parameter(
-                    "query", inspect.Parameter.POSITIONAL_OR_KEYWORD, annotation=str
-                )
+        fields = tool_args_schema.__fields__
+        params = [
+            inspect.Parameter(
+                name=field_name,
+                kind=inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                default=field_info.default,
+                annotation=field_info.field_info,
             )
-        new_signature = inspect.Signature(parameters, return_annotation=dict[str, Any])
-        setattr(rag_function, "__signature__", new_signature)
-
-        # Set the function name and docstring
-        doc_string = f"{tool_description}\n\n"
-        doc_string += "Parameters:\n"
-        for field_name, field in tool_args_schema.__fields__.items():
-            type_name = field.type_.__name__
-            if field.allow_none:
-                type_name = f"Optional[{type_name}]"
-
-            default_info = ""
-            if field.default is not None:
-                default_info = f" (default: {field.default})"
-            elif field.default_factory is not None:
-                default_info = " (default: set by factory)"
-
-            doc_string += f"- {field_name} ({type_name}): {field.field_info.description}{default_info}\n"
-
-        doc_string += "\nReturns: a dict[str, Any] with the following:\n"
-        doc_string += (
-            "- response: The response string in markdown format with citations.\n"
-        )
-        doc_string += "- citation_metadata: a dictionary of metadata for each citation included in the response string.\n"
-        doc_string += "- response_factual_consistency: a value representing confidence in the response being factually correct (1.0=high, 0.0=low).\n"
+            for field_name, field_info in fields.items()
+        ]
 
+        # 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)
-        rag_function.__doc__ = doc_string
 
         # Create the tool
         tool = FunctionTool.from_defaults(
             fn=rag_function,
             name=tool_name,
-            description=doc_string,
+            description=tool_description,
             fn_schema=tool_args_schema,
         )
         return VectaraTool(tool, ToolType.QUERY)
@@ -283,7 +274,7 @@ class ToolsFactory:
         """
         Get a tool from the llama_index hub.
 
-        Parameters:
+        Args:
             tool_package_name (str): The name of the tool package.
             tool_spec_name (str): The name of the tool spec.
             tool_name_prefix (str): The prefix to add to the tool names (added to every tool in the spec).
@@ -329,6 +320,9 @@ class ToolsFactory:
         return [self.create_tool(tool) for tool in [summarize_text, rephrase_text]]
 
     def guardrail_tools(self) -> List[FunctionTool]:
+        """
+        Create a list of guardrail tools to avoid controversial topics.
+        """
         return [
             self.create_tool(tool)
             for tool in [guardrails_no_politics, guardrails_be_polite]
@@ -341,6 +335,9 @@ class ToolsFactory:
         return self.get_llama_index_tools("yahoo_finance", "YahooFinanceToolSpec")
 
     def legal_tools(self) -> List[FunctionTool]:
+        """
+        Create a list of legal tools.
+        """
         def summarize_legal_text(
             text: str = Field(description="the original text."),
         ) -> str:

vectara_agentic/utils.py

@@ -10,23 +10,22 @@ from llama_index.llms.anthropic import Anthropic
 from llama_index.llms.together import TogetherLLM
 from llama_index.llms.groq import Groq
 from llama_index.llms.fireworks import Fireworks
+import tiktoken
 
 from .types import LLMRole, AgentType, ModelProvider
 
 provider_to_default_model_name = {
-    ModelProvider.OPENAI: "gpt-4o",
+    ModelProvider.OPENAI: "gpt-4o-2024-08-06",
     ModelProvider.ANTHROPIC: "claude-3-5-sonnet-20240620",
     ModelProvider.TOGETHER: "meta-llama/Meta-Llama-3.1-70B-Instruct-Turbo",
-    ModelProvider.GROQ: "mixtral-8x7b-32768",
+    ModelProvider.GROQ: "llama3-groq-70b-8192-tool-use-preview",
     ModelProvider.FIREWORKS: "accounts/fireworks/models/firefunction-v2",
 }
 
 DEFAULT_MODEL_PROVIDER = ModelProvider.OPENAI
 
-
-def get_llm(role: LLMRole) -> LLM:
-    """Get the LLM for the specified role."""
-    agent_type = AgentType(os.getenv("VECTARA_AGENTIC_AGENT_TYPE", AgentType.OPENAI))
+def _get_llm_params_for_role(role: LLMRole) -> tuple[str, str]:
+    """Get the model provider and model name for the specified role."""
     if role == LLMRole.TOOL:
         model_provider = ModelProvider(
             os.getenv("VECTARA_AGENTIC_TOOL_LLM_PROVIDER", DEFAULT_MODEL_PROVIDER)
@@ -44,6 +43,7 @@ def get_llm(role: LLMRole) -> LLM:
             provider_to_default_model_name.get(model_provider),
         )
 
+    agent_type = AgentType(os.getenv("VECTARA_AGENTIC_AGENT_TYPE", AgentType.OPENAI))
     if (
         role == LLMRole.MAIN
         and agent_type == AgentType.OPENAI
@@ -53,6 +53,22 @@ def get_llm(role: LLMRole) -> LLM:
             "OpenAI agent requested but main model provider is not OpenAI."
         )
 
+    return model_provider, model_name
+
+def get_tokenizer_for_model(role: LLMRole) -> str:
+    """Get the tokenizer for the specified model."""
+    model_provider, model_name = _get_llm_params_for_role(role)
+    if model_provider == ModelProvider.OPENAI:
+        return tiktoken.encoding_for_model(model_name).encode
+    elif model_provider == ModelProvider.ANTHROPIC:
+        return Anthropic().tokenizer
+    else:
+        return None
+
+def get_llm(role: LLMRole) -> LLM:
+    """Get the LLM for the specified role."""
+    model_provider, model_name = _get_llm_params_for_role(role)
+
     if model_provider == ModelProvider.OPENAI:
         llm = OpenAI(model=model_name, temperature=0)
     elif model_provider == ModelProvider.ANTHROPIC:

{vectara_agentic-0.1.4.dist-info → vectara_agentic-0.1.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vectara_agentic
-Version: 0.1.4
+Version: 0.1.5
 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
@@ -37,6 +37,7 @@ Requires-Dist: pylint ==3.2.6
 Requires-Dist: flake8 ==7.1.0
 Requires-Dist: pymongo ==4.6.1
 Requires-Dist: python-dotenv ==1.0.1
+Requires-Dist: tiktoken ==0.7.0
 
 # vectara-agentic
 
@@ -202,7 +203,7 @@ We have created a few example AI assistants that you can look at for inspiration
 ## 🤝 Contributing
 
 Contributions, issues and feature requests are welcome and appreciated!<br />
-Feel free to check [issues page](https://github.com/vectara/py-vectara-agentic/issues). You can also take a look at the [contributing guide](https://github.com/vectara/py-vectara-agentic/blob/master/CONTRIBUTING.md).
+Feel free to check [issues page](https://github.com/vectara/py-vectara-agentic/issues). You can also take a look at the [contributing guide](https://github.com/vectara/py-vectara-agentic/blob/main/CONTRIBUTING.md).
 
 ## Show your support
 

vectara_agentic-0.1.5.dist-info/RECORD

@@ -0,0 +1,13 @@
+vectara_agentic/__init__.py,sha256=CRKtLZdGj_s9ynKBOVkT_Qqhm7WwxGpZGzyeHZG-1aI,432
+vectara_agentic/_callback.py,sha256=3phD394HQICg5BWpMTE3a7DUUVl5NWVIkdgCDytS0gc,3564
+vectara_agentic/_prompts.py,sha256=u8HqpfV42fdBUf3ZNjDm5kPJXNncLSTWU-4Js7-ipEA,4152
+vectara_agentic/agent.py,sha256=hvrZ-Uvu7NyuH57lcLuv7pAczxh632flkY_f9YM7hMc,10700
+vectara_agentic/tools.py,sha256=Rg2YTMlOJbYyUGk17nBoiNTShkvdhziEsh0GTNtxS84,15617
+vectara_agentic/tools_catalog.py,sha256=Wc-j7p6LG4420KmM8SUKFtgI2b1IwryXqbALGDEvmAI,4266
+vectara_agentic/types.py,sha256=CFjjxaYhflsFDsE2ZNrZgWqman_r2HJQ-nOvuUiX3IY,804
+vectara_agentic/utils.py,sha256=7nocKsFT7wqaDloJGJNwJA2nM-bK_nMhMQ3Ex0OUd3w,3090
+vectara_agentic-0.1.5.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+vectara_agentic-0.1.5.dist-info/METADATA,sha256=krMV0dy17gda7i0sgsSnQlOFjvxBFfqluH0rI96tcbo,10336
+vectara_agentic-0.1.5.dist-info/WHEEL,sha256=R0nc6qTxuoLk7ShA2_Y-UWkN8ZdfDBG2B6Eqpz2WXbs,91
+vectara_agentic-0.1.5.dist-info/top_level.txt,sha256=qT7JB9Xz7byehzlPd_rY4WWEAvPMhs63WMWgPsFthxU,16
+vectara_agentic-0.1.5.dist-info/RECORD,,

vectara_agentic-0.1.4.dist-info/RECORD

@@ -1,13 +0,0 @@
-vectara_agentic/__init__.py,sha256=CRKtLZdGj_s9ynKBOVkT_Qqhm7WwxGpZGzyeHZG-1aI,432
-vectara_agentic/_callback.py,sha256=3phD394HQICg5BWpMTE3a7DUUVl5NWVIkdgCDytS0gc,3564
-vectara_agentic/_prompts.py,sha256=u8HqpfV42fdBUf3ZNjDm5kPJXNncLSTWU-4Js7-ipEA,4152
-vectara_agentic/agent.py,sha256=PXKsFe3IKHkypkErzQZclxgRVI_d_kRwy1KsBTjIhKc,5846
-vectara_agentic/tools.py,sha256=79dZX2BBJeML9KglFlXiGxzfyUaoyX63DLwuexAQ8NE,16250
-vectara_agentic/tools_catalog.py,sha256=Wc-j7p6LG4420KmM8SUKFtgI2b1IwryXqbALGDEvmAI,4266
-vectara_agentic/types.py,sha256=CFjjxaYhflsFDsE2ZNrZgWqman_r2HJQ-nOvuUiX3IY,804
-vectara_agentic/utils.py,sha256=8YqxRqgm6qbjoH-LotpeHRjKWRejn9VJoqM5BbsD0NU,2408
-vectara_agentic-0.1.4.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-vectara_agentic-0.1.4.dist-info/METADATA,sha256=No8ef-KKrHbAQc8ZdImNqkRqS41jIx2fObV9N_tI4Gc,10306
-vectara_agentic-0.1.4.dist-info/WHEEL,sha256=R0nc6qTxuoLk7ShA2_Y-UWkN8ZdfDBG2B6Eqpz2WXbs,91
-vectara_agentic-0.1.4.dist-info/top_level.txt,sha256=qT7JB9Xz7byehzlPd_rY4WWEAvPMhs63WMWgPsFthxU,16
-vectara_agentic-0.1.4.dist-info/RECORD,,