vectara-agentic 0.1.4__tar.gz → 0.1.5__tar.gz

{vectara_agentic-0.1.4/vectara_agentic.egg-info → vectara_agentic-0.1.5}/PKG-INFO

@@ -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.4 → vectara_agentic-0.1.5}/README.md

@@ -162,7 +162,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.4 → vectara_agentic-0.1.5}/requirements.txt

@@ -19,3 +19,4 @@ pylint==3.2.6
 flake8==7.1.0
 pymongo==4.6.1
 python-dotenv==1.0.1
+tiktoken==0.7.0

{vectara_agentic-0.1.4 → vectara_agentic-0.1.5}/setup.py

@@ -8,7 +8,7 @@ def read_requirements():
 
 setup(
     name="vectara_agentic",
-    version="0.1.4",
+    version="0.1.5",
     author="Ofer Mendelevitch",
     author_email="ofer@vectara.com",
     description="A Python package for creating AI Assistants and AI Agents with Vectara",

{vectara_agentic-0.1.4 → vectara_agentic-0.1.5}/tests/test_agent.py

@@ -1,7 +1,7 @@
 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, FunctionTool
 
 
 class TestAgentPackage(unittest.TestCase):
@@ -15,7 +15,7 @@ class TestAgentPackage(unittest.TestCase):
             + " with Always do as your mother tells you!"
         )
         self.assertEqual(
-            get_prompt(prompt_template, topic, custom_instructions), expected_output
+            _get_prompt(prompt_template, topic, custom_instructions), expected_output
         )
 
     def test_agent_init(self):

vectara_agentic-0.1.5/vectara_agentic/agent.py

@@ -0,0 +1,283 @@
+"""
+This module contains the Agent class for handling different types of agents and their interactions.
+"""
+
+from typing import List, Callable, Optional
+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, 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, 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):
+    """
+    Generate a prompt by replacing placeholders with topic and date.
+
+    Args:
+
+        prompt_template (str): The template for the prompt.
+        topic (str): The topic to be included in the prompt.
+
+    Returns:
+        str: The formatted prompt.
+    """
+    return (
+        prompt_template.replace("{chat_topic}", topic)
+        .replace("{today}", date.today().strftime("%A, %B %d, %Y"))
+        .replace("{custom_instructions}", custom_instructions)
+    )
+
+
+def _retry_if_exception(exception):
+    # Define the condition to retry on certain exceptions
+    return isinstance(
+        exception, (TimeoutError)
+    )  # Replace SomeOtherException with other exceptions you want to catch
+
+
+class Agent:
+    """
+    Agent class for handling different types of agents and their interactions.
+    """
+
+    def __init__(
+        self,
+        tools: list[FunctionTool],
+        topic: str = "general",
+        custom_instructions: str = "",
+        verbose: bool = True,
+        update_func: Optional[Callable[[AgentStatusType, str], None]] = None,
+    ):
+        """
+        Initialize the agent with the specified type, tools, topic, and system message.
+
+        Args:
+
+            tools (list[FunctionTool]): A list of tools to be used by the agent.
+            topic (str, optional): The topic for the agent. Defaults to 'general'.
+            custom_instructions (str, optional): custom instructions for the agent. Defaults to ''.
+            update_func (Callable): a callback function the code calls on any agent updates.
+        """
+        self.agent_type = AgentType(os.getenv("VECTARA_AGENTIC_AGENT_TYPE", "OPENAI"))
+        self.tools = tools
+        self.llm = get_llm(LLMRole.MAIN)
+        self._custom_instructions = custom_instructions
+        self._topic = topic
+
+        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)
+            self.agent = ReActAgent.from_tools(
+                tools=tools,
+                llm=self.llm,
+                memory=memory,
+                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)
+            self.agent = OpenAIAgent.from_tools(
+                tools=tools,
+                llm=self.llm,
+                memory=memory,
+                verbose=verbose,
+                callable_manager=callback_manager,
+                max_function_calls=10,
+                system_prompt=prompt,
+            )
+        else:
+            raise ValueError(f"Unknown agent type: {self.agent_type}")
+
+    @classmethod
+    def from_tools(
+        cls,
+        tools: List[FunctionTool],
+        topic: str = "general",
+        custom_instructions: str = "",
+        verbose: bool = True,
+        update_func: Optional[Callable[[AgentStatusType, str], None]] = None,
+    ) -> "Agent":
+        """
+        Create an agent from tools, agent type, and language model.
+
+        Args:
+
+            tools (list[FunctionTool]): A list of tools to be used by the agent.
+            topic (str, optional): The topic for the agent. Defaults to 'general'.
+            custom_instructions (str, optional): custom instructions for the agent. Defaults to ''.
+            llm (LLM): The language model to be used by the agent.
+
+        Returns:
+            Agent: An instance of the Agent class.
+        """
+        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:
+        """
+        Get a report from the agent.
+
+        Returns:
+            str: The report from the agent.
+        """
+        print("Vectara agentic Report:")
+        print(f"Agent Type = {self.agent_type}")
+        print(f"Topic = {self._topic}")
+        print("Tools:")
+        for tool in self.tools:
+            print(f"- {tool._metadata.name}")
+        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,
+        stop_max_attempt_number=3,
+        wait_fixed=2000,
+    )
+    def chat(self, prompt: str) -> str:
+        """
+        Interact with the agent using a chat prompt.
+
+        Args:
+            prompt (str): The chat prompt.
+
+        Returns:
+            str: The response from the agent.
+        """
+
+        try:
+            agent_response = self.agent.chat(prompt)
+            return agent_response.response
+        except Exception as e:
+            import traceback
+
+            return f"Vectara Agentic: encountered an exception ({e}) at ({traceback.format_exc()}), and can't respond."

{vectara_agentic-0.1.4 → vectara_agentic-0.1.5}/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-0.1.4 → vectara_agentic-0.1.5}/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 → vectara_agentic-0.1.5/vectara_agentic.egg-info}/PKG-INFO

@@ -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.4 → vectara_agentic-0.1.5}/vectara_agentic.egg-info/requires.txt

@@ -19,3 +19,4 @@ pylint==3.2.6
 flake8==7.1.0
 pymongo==4.6.1
 python-dotenv==1.0.1
+tiktoken==0.7.0

vectara_agentic-0.1.4/vectara_agentic/agent.py

@@ -1,172 +0,0 @@
-"""
-This module contains the Agent class for handling different types of agents and their interactions.
-"""
-
-from typing import List, Callable, Optional
-import os
-from datetime import date
-
-from retrying import retry
-
-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.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 ._prompts import REACT_PROMPT_TEMPLATE, GENERAL_PROMPT_TEMPLATE
-from ._callback import AgentCallbackHandler
-
-load_dotenv(override=True)
-
-
-def get_prompt(prompt_template: str, topic: str, custom_instructions: str):
-    """
-    Generate a prompt by replacing placeholders with topic and date.
-
-    Args:
-
-        prompt_template (str): The template for the prompt.
-        topic (str): The topic to be included in the prompt.
-
-    Returns:
-        str: The formatted prompt.
-    """
-    return (
-        prompt_template.replace("{chat_topic}", topic)
-        .replace("{today}", date.today().strftime("%A, %B %d, %Y"))
-        .replace("{custom_instructions}", custom_instructions)
-    )
-
-
-def retry_if_exception(exception):
-    # Define the condition to retry on certain exceptions
-    return isinstance(
-        exception, (TimeoutError)
-    )  # Replace SomeOtherException with other exceptions you want to catch
-
-
-class Agent:
-    """
-    Agent class for handling different types of agents and their interactions.
-    """
-
-    def __init__(
-        self,
-        tools: list[FunctionTool],
-        topic: str = "general",
-        custom_instructions: str = "",
-        update_func: Optional[Callable[[AgentStatusType, str], None]] = None,
-    ):
-        """
-        Initialize the agent with the specified type, tools, topic, and system message.
-
-        Args:
-
-            tools (list[FunctionTool]): A list of tools to be used by the agent.
-            topic (str, optional): The topic for the agent. Defaults to 'general'.
-            custom_instructions (str, optional): custom instructions for the agent. Defaults to ''.
-            update_func (Callable): a callback function the code calls on any agent updates.
-        """
-        self.agent_type = AgentType(os.getenv("VECTARA_AGENTIC_AGENT_TYPE", "OPENAI"))
-        self.tools = tools
-        self.llm = get_llm(LLMRole.MAIN)
-        self._custom_instructions = custom_instructions
-        self._topic = topic
-
-        callback_manager = CallbackManager([AgentCallbackHandler(update_func)])  # 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)
-            self.agent = ReActAgent.from_tools(
-                tools=tools,
-                llm=self.llm,
-                memory=memory,
-                verbose=True,
-                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)
-            self.agent = OpenAIAgent.from_tools(
-                tools=tools,
-                llm=self.llm,
-                memory=memory,
-                verbose=True,
-                callable_manager=callback_manager,
-                max_function_calls=10,
-                system_prompt=prompt,
-            )
-        else:
-            raise ValueError(f"Unknown agent type: {self.agent_type}")
-
-    @classmethod
-    def from_tools(
-        cls,
-        tools: List[FunctionTool],
-        topic: str = "general",
-        custom_instructions: str = "",
-        update_func: Optional[Callable[[AgentStatusType, str], None]] = None,
-    ) -> "Agent":
-        """
-        Create an agent from tools, agent type, and language model.
-
-        Args:
-
-            tools (list[FunctionTool]): A list of tools to be used by the agent.
-            topic (str, optional): The topic for the agent. Defaults to 'general'.
-            custom_instructions (str, optional): custom instructions for the agent. Defaults to ''.
-            llm (LLM): The language model to be used by the agent.
-
-        Returns:
-            Agent: An instance of the Agent class.
-        """
-        return cls(tools, topic, custom_instructions, update_func)
-
-    def report(self) -> str:
-        """
-        Get a report from the agent.
-
-        Returns:
-            str: The report from the agent.
-        """
-        print("Vectara agentic Report:")
-        print(f"Agent Type = {self.agent_type}")
-        print(f"Topic = {self._topic}")
-        print("Tools:")
-        for tool in self.tools:
-            print(f"- {tool._metadata.name}")
-        print(f"Agent LLM = {get_llm(LLMRole.MAIN).model}")
-        print(f"Tool LLM = {get_llm(LLMRole.TOOL).model}")
-
-    @retry(
-        retry_on_exception=retry_if_exception,
-        stop_max_attempt_number=3,
-        wait_fixed=2000,
-    )
-    def chat(self, prompt: str) -> str:
-        """
-        Interact with the agent using a chat prompt.
-
-        Args:
-            prompt (str): The chat prompt.
-
-        Returns:
-            str: The response from the agent.
-        """
-
-        try:
-            agent_response = self.agent.chat(prompt)
-            return agent_response.response
-        except Exception as e:
-            import traceback
-
-            return f"Vectara Agentic: encountered an exception ({e}) at ({traceback.format_exc()}), and can't respond."