vectara-agentic 0.1.8__py3-none-any.whl → 0.1.10__py3-none-any.whl

vectara_agentic/__init__.py

@@ -3,7 +3,7 @@ vectara_agentic package.
 """
 
 # Define the package version
-__version__ = "0.1.8"
+__version__ = "0.1.10"
 
 # Import classes and functions from modules
 # from .module1 import Class1, function1

vectara_agentic/_prompts.py

@@ -88,16 +88,17 @@ If this format is used, the user will respond in the following format:
 Observation: tool response
 ```
 
-You should keep repeating the above format till you have enough information to answer the question without using any more tools. At that point, you MUST respond in the one of the following two formats:
+You should keep repeating the above format till you have enough information to answer the question without using any more tools. 
+At that point, you MUST respond in the one of the following two formats (and do not include any Action):
 
 ```
 Thought: I can answer without using any more tools. I'll use the user's language to answer
-Answer: [your answer here (In the same language as the user's question)]
+Answer: [your answer here (In the same language as the user's question, and maintain any references/citations)]
 ```
 
 ```
 Thought: I cannot answer the question with the provided tools.
-Answer: [your answer here (In the same language as the user's question)]
+Answer: [your answer here (In the same language as the user's question, and maintain any references/citations)]
 ```
 
 ## Current Conversation

vectara_agentic/agent.py

@@ -1,16 +1,20 @@
 """
 This module contains the Agent class for handling different types of agents and their interactions.
 """
-
-from typing import List, Callable, Optional
+from typing import List, Callable, Optional, Dict, Any
 import os
 from datetime import date
 import time
+import json
+import dill
+
+import logging
+logger = logging.getLogger('opentelemetry.exporter.otlp.proto.http.trace_exporter')
+logger.setLevel(logging.CRITICAL)
 
 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
@@ -20,15 +24,18 @@ from llama_index.core.callbacks.base_handler import BaseCallbackHandler
 from llama_index.agent.openai import OpenAIAgent
 from llama_index.core.memory import ChatMemoryBuffer
 from llama_index.core import set_global_handler
+from llama_index.core.tools.types import ToolMetadata
 
+import phoenix as px
 
 from dotenv import load_dotenv
 
-from .types import AgentType, AgentStatusType, LLMRole, ObserverType
+from .types import AgentType, AgentStatusType, LLMRole, ObserverType, ToolType
 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
+from .tools import VectaraToolFactory, VectaraTool
+
 
 load_dotenv(override=True)
 
@@ -64,7 +71,6 @@ class Agent:
     """
     Agent class for handling different types of agents and their interactions.
     """
-
     def __init__(
         self,
         tools: list[FunctionTool],
@@ -72,6 +78,7 @@ class Agent:
         custom_instructions: str = "",
         verbose: bool = True,
         update_func: Optional[Callable[[AgentStatusType, str], None]] = None,
+        agent_type: AgentType = AgentType(os.getenv("VECTARA_AGENTIC_AGENT_TYPE", "OPENAI")),
     ) -> None:
         """
         Initialize the agent with the specified type, tools, topic, and system message.
@@ -84,7 +91,7 @@ class Agent:
             verbose (bool, optional): Whether the agent should print its steps. Defaults to True.
             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.agent_type = agent_type
         self.tools = tools
         self.llm = get_llm(LLMRole.MAIN)
         self._custom_instructions = custom_instructions
@@ -113,7 +120,7 @@ class Agent:
                 memory=memory,
                 verbose=verbose,
                 react_chat_formatter=ReActChatFormatter(system_header=prompt),
-                max_iterations=20,
+                max_iterations=30,
                 callable_manager=callback_manager,
             )
         elif self.agent_type == AgentType.OPENAI:
@@ -124,7 +131,7 @@ class Agent:
                 memory=memory,
                 verbose=verbose,
                 callable_manager=callback_manager,
-                max_function_calls=10,
+                max_function_calls=20,
                 system_prompt=prompt,
             )
         elif self.agent_type == AgentType.LLMCOMPILER:
@@ -139,11 +146,55 @@ class Agent:
 
         observer = ObserverType(os.getenv("VECTARA_AGENTIC_OBSERVER_TYPE", "NO_OBSERVER"))
         if observer == ObserverType.ARIZE_PHOENIX:
-            set_global_handler("arize_phoenix", endpoint="https://llamatrace.com/v1/traces")
-            print("Arize Phoenix observer set.")
+            if os.environ.get("OTEL_EXPORTER_OTLP_HEADERS", None):
+                set_global_handler("arize_phoenix", endpoint="https://llamatrace.com/v1/traces")
+                print("Arize Phoenix observer set. https://llamatrace.com")
+            else:
+                px.launch_app()
+                set_global_handler("arize_phoenix", endpoint="http://localhost:6006/v1/traces")
+                print("Arize Phoenix observer set. http://localhost:6006/.")
         else:
             print("No observer set.")
 
+    def __eq__(self, other):
+        if not isinstance(other, Agent):
+            print(f"Comparison failed: other is not an instance of Agent. (self: {type(self)}, other: {type(other)})")
+            return False
+
+        # Compare agent_type
+        if self.agent_type != other.agent_type:
+            print(f"Comparison failed: agent_type differs. (self.agent_type: {self.agent_type}, other.agent_type: {other.agent_type})")
+            return False
+
+        # Compare tools
+        if self.tools != other.tools:
+            print(f"Comparison failed: tools differ. (self.tools: {self.tools}, other.tools: {other.tools})")
+            return False
+
+        # Compare topic
+        if self._topic != other._topic:
+            print(f"Comparison failed: topic differs. (self.topic: {self._topic}, other.topic: {other._topic})")
+            return False
+
+        # Compare custom_instructions
+        if self._custom_instructions != other._custom_instructions:
+            print(f"Comparison failed: custom_instructions differ. (self.custom_instructions: {self._custom_instructions}, other.custom_instructions: {other._custom_instructions})")
+            return False
+
+        # Compare verbose
+        if self.verbose != other.verbose:
+            print(f"Comparison failed: verbose differs. (self.verbose: {self.verbose}, other.verbose: {other.verbose})")
+            return False
+
+        # Compare agent
+        if self.agent.memory.chat_store != other.agent.memory.chat_store:
+            print(f"Comparison failed: agent memory differs. (self.agent: {repr(self.agent.memory.chat_store)}, other.agent: {repr(other.agent.memory.chat_store)})")
+            return False
+
+        # If all comparisons pass
+        print("All comparisons passed. Objects are equal.")
+        return True
+
     @classmethod
     def from_tools(
         cls,
@@ -174,11 +225,11 @@ class Agent:
     def from_corpus(
         cls,
         tool_name: str,
-        vectara_customer_id: str,
-        vectara_corpus_id: str,
-        vectara_api_key: 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_api_key: str = str(os.environ.get("VECTARA_API_KEY", "")),
         verbose: bool = False,
         vectara_filter_fields: list[dict] = [],
         vectara_lambda_val: float = 0.005,
@@ -195,12 +246,12 @@ class Agent:
         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.
+            vectara_corpus_id (str): The Vectara corpus ID (or comma separated list of IDs).
             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, optional): Whether to print verbose output.
-            vectara_filter_fields (List[dict], optional): The filterable attributes (each dict includes name, type, and description).
+            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_rerank_k (int, optional): The number of results to use with reranking.
@@ -216,9 +267,10 @@ class Agent:
                                          vectara_customer_id=vectara_customer_id,
                                          vectara_corpus_id=vectara_corpus_id)
         field_definitions = {}
-        field_definitions['query'] = (str, Field(description="The user query"))
+        field_definitions['query'] = (str, Field(description="The user query"))  # type: ignore
         for field in vectara_filter_fields:
-            field_definitions[field['name']] = (eval(field['type']), Field(description=field['description'], default=None))  # type: ignore
+            field_definitions[field['name']] = (eval(field['type']), 
+                                                Field(description=field['description']))  # type: ignore
         QueryArgs = create_model(   # type: ignore
             "QueryArgs",
             **field_definitions
@@ -307,3 +359,121 @@ class Agent:
         except Exception as e:
             import traceback
             return f"Vectara Agentic: encountered an exception ({e}) at ({traceback.format_exc()}), and can't respond."
+
+    # Serialization methods
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Serialize the Agent instance to a dictionary."""
+        tool_info = []
+
+        for tool in self.tools:
+            tool_dict = {
+                "tool_type": tool.tool_type.value,
+                "name": tool._metadata.name,
+                "description": tool._metadata.description,
+                "fn": dill.dumps(tool.fn).decode('latin-1') if tool.fn else None,  # Serialize fn
+                "async_fn": dill.dumps(tool.async_fn).decode('latin-1') if tool.async_fn else None,  # Serialize async_fn
+            }
+            tool_info.append(tool_dict)
+
+        return {
+            "agent_type": self.agent_type.value,
+            "tools": tool_info,
+            "topic": self._topic,
+            "custom_instructions": self._custom_instructions,
+            "verbose": self.verbose,
+        }
+
+
+    def dumps(self) -> str:
+        """Serialize the Agent instance to a JSON string."""
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def loads(cls, data: str) -> "Agent":
+        """Create an Agent instance from a JSON string."""
+        return cls.from_dict(json.loads(data))
+
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Serialize the Agent instance to a dictionary."""
+        tool_info = []
+
+        for tool in self.tools:
+            # Serialize each tool's metadata, function, and dynamic model schema (QueryArgs)
+            tool_dict = {
+                "tool_type": tool.tool_type.value,
+                "name": tool._metadata.name,
+                "description": tool._metadata.description,
+                "fn": dill.dumps(tool.fn).decode('latin-1') if tool.fn else None,  # Serialize fn
+                "async_fn": dill.dumps(tool.async_fn).decode('latin-1') if tool.async_fn else None,  # Serialize async_fn
+                "fn_schema": tool._metadata.fn_schema.model_json_schema() if hasattr(tool._metadata, 'fn_schema') else None,  # Serialize schema if available
+            }
+            tool_info.append(tool_dict)
+
+        return {
+            "agent_type": self.agent_type.value,
+            "memory": dill.dumps(self.agent.memory).decode('latin-1'),
+            "tools": tool_info,
+            "topic": self._topic,
+            "custom_instructions": self._custom_instructions,
+            "verbose": self.verbose,
+        }
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "Agent":
+        """Create an Agent instance from a dictionary."""
+        agent_type = AgentType(data["agent_type"])
+        tools = []
+
+        JSON_TYPE_TO_PYTHON = {
+            "string": "str",
+            "integer": "int",
+            "boolean": "bool",
+            "array": "list",
+            "object": "dict",
+            "number": "float",
+        }
+    
+        for tool_data in data["tools"]:
+            # Recreate the dynamic model using the schema info
+            if tool_data.get("fn_schema"):
+                field_definitions = {}
+                for field,values in tool_data["fn_schema"]["properties"].items():
+                    if 'default' in values:
+                        field_definitions[field] = (eval(JSON_TYPE_TO_PYTHON.get(values['type'], values['type'])), 
+                                                             Field(description=values['description'], default=values['default']))  # type: ignore
+                    else:
+                        field_definitions[field] = (eval(JSON_TYPE_TO_PYTHON.get(values['type'], values['type'])), 
+                                                            Field(description=values['description']))    # type: ignore
+                query_args_model = create_model(   # type: ignore
+                    "QueryArgs",
+                    **field_definitions
+                )
+            else:
+                query_args_model = create_model("QueryArgs")
+
+            fn = dill.loads(tool_data["fn"].encode('latin-1')) if tool_data["fn"] else None
+            async_fn = dill.loads(tool_data["async_fn"].encode('latin-1')) if tool_data["async_fn"] else None
+
+            tool = VectaraTool.from_defaults(
+                tool_type=ToolType(tool_data["tool_type"]),
+                name=tool_data["name"],
+                description=tool_data["description"],
+                fn=fn,
+                async_fn=async_fn,
+                fn_schema=query_args_model  # Re-assign the recreated dynamic model
+            )
+            tools.append(tool)
+
+        agent = cls(
+            tools=tools,
+            agent_type=agent_type,
+            topic=data["topic"],
+            custom_instructions=data["custom_instructions"],
+            verbose=data["verbose"],
+        )
+        memory = dill.loads(data["memory"].encode('latin-1')) if data.get("memory") else None
+        if memory:
+            agent.agent.memory = memory
+        return agent

vectara_agentic/tools.py

@@ -5,6 +5,7 @@ This module contains the ToolsFactory class for creating agent tools.
 import inspect
 import re
 import importlib
+import os
 
 from typing import Callable, List, Any, Optional, Type
 from pydantic import BaseModel, Field
@@ -80,12 +81,31 @@ class VectaraTool(FunctionTool):
         tool = FunctionTool.from_defaults(fn, name, description, return_direct, fn_schema, async_fn, tool_metadata)
         vectara_tool = cls(
             tool_type=tool_type,
-            fn=tool.fn,
-            metadata=tool.metadata,
-            async_fn=tool.async_fn
+            fn=tool._fn,
+            metadata=tool._metadata,
+            async_fn=tool._async_fn
         )
         return vectara_tool
 
+    def __eq__(self, other):
+        if self.tool_type != other.tool_type:
+            return False
+
+        # Check if fn_schema is an instance of a BaseModel or a class itself (metaclass)
+        self_schema_dict = self.metadata.fn_schema.model_fields
+        other_schema_dict = other.metadata.fn_schema.model_fields
+        is_equal = True
+        for key in self_schema_dict.keys():
+            if key not in other_schema_dict:
+                is_equal = False
+                break
+            if (self_schema_dict[key].annotation != other_schema_dict[key].annotation or
+                self_schema_dict[key].description != other_schema_dict[key].description or
+                self_schema_dict[key].is_required() != other_schema_dict[key].is_required()):
+                is_equal = False
+                break
+        return is_equal
+
 
 class VectaraToolFactory:
     """
@@ -94,20 +114,21 @@ class VectaraToolFactory:
 
     def __init__(
         self,
-        vectara_customer_id: str,
-        vectara_corpus_id: str,
-        vectara_api_key: str,
+        vectara_customer_id: str = str(os.environ.get("VECTARA_CUSTOMER_ID", "")),
+        vectara_corpus_id: str = str(os.environ.get("VECTARA_CORPUS_ID", "")),
+        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.
+            vectara_corpus_id (str): The Vectara corpus ID (or comma separated list of IDs).
             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
+        self.num_corpora = len(vectara_corpus_id.split(","))
 
     def create_rag_tool(
         self,
@@ -154,6 +175,7 @@ class VectaraToolFactory:
             vectara_api_key=self.vectara_api_key,
             vectara_customer_id=self.vectara_customer_id,
             vectara_corpus_id=self.vectara_corpus_id,
+            x_source_str="vectara-agentic"
         )
 
         def _build_filter_string(kwargs):
@@ -186,7 +208,7 @@ class VectaraToolFactory:
                 summary_response_lang=summary_response_lang,
                 summary_prompt_name=vectara_summarizer,
                 reranker=reranker,
-                rerank_k=rerank_k,
+                rerank_k=rerank_k if rerank_k*self.num_corpora<=100 else int(100/self.num_corpora),
                 mmr_diversity_bias=mmr_diversity_bias,
                 n_sentence_before=n_sentences_before,
                 n_sentence_after=n_sentences_after,
@@ -233,17 +255,18 @@ class VectaraToolFactory:
                     raw_output={'response': msg}
                 )
                 
-
             res = {
                 "response": response.response,
                 "references_metadata": citation_metadata,
             }
-
-            tool_output = f"""
-                Response: '''{res['response']}'''
-                References:
-                {res['references_metadata']}
-            """
+            if len(citation_metadata) > 0:
+                tool_output = f"""
+                    Response: '''{res['response']}'''
+                    References:
+                    {res['references_metadata']}
+                """
+            else:
+                tool_output = f"Response: '''{res['response']}'''"
             out = ToolOutput(
                 tool_name=rag_function.__name__,
                 content=tool_output,
@@ -252,7 +275,7 @@ class VectaraToolFactory:
             )
             return out
 
-        fields = tool_args_schema.__fields__
+        fields = tool_args_schema.model_fields
         params = [
             inspect.Parameter(
                 name=field_name,

{vectara_agentic-0.1.8.dist-info → vectara_agentic-0.1.10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vectara_agentic
-Version: 0.1.8
+Version: 0.1.10
 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
@@ -31,11 +31,13 @@ Requires-Dist: llama-index-tools-arxiv ==0.2.0
 Requires-Dist: llama-index-tools-database ==0.2.0
 Requires-Dist: llama-index-tools-google ==0.2.0
 Requires-Dist: llama-index-tools-tavily-research ==0.2.0
+Requires-Dist: llama-index-callbacks-arize-phoenix ==0.2.1
 Requires-Dist: pydantic ==2.8.2
 Requires-Dist: retrying ==1.3.4
-Requires-Dist: pymongo ==4.6.1
+Requires-Dist: pymongo ==4.6.3
 Requires-Dist: python-dotenv ==1.0.1
 Requires-Dist: tiktoken ==0.7.0
+Requires-Dist: dill ==0.3.8
 
 # vectara-agentic
 
@@ -63,7 +65,7 @@ Requires-Dist: tiktoken ==0.7.0
 - [Vectara account](https://console.vectara.com/signup/?utm_source=github&utm_medium=code&utm_term=DevRel&utm_content=vectara-agentic&utm_campaign=github-code-DevRel-vectara-agentic)
 - A Vectara corpus with an [API key](https://docs.vectara.com/docs/api-keys)
 - [Python 3.10 or higher](https://www.python.org/downloads/)
-- OpenAI API key (or API keys for Anthropic, TOGETHER.AI, Fireworks AI, Cohere, or GROQ)
+- OpenAI API key (or API keys for Anthropic, TOGETHER.AI, Fireworks AI, Cohere or GROQ)
 
 ## Installation
 
@@ -97,6 +99,8 @@ query_financial_reports = vec_factory.create_rag_tool(
 )
 ```
 
+Note that `VECTARA_CORPUS_ID` can be a single ID or a comma-separated list of IDs.
+
 2. **Create other tools (optional)**
 
 In addition to RAG tools, you can generate a lot of other types of tools the agent can use. These could be mathematical tools, tools 
@@ -181,6 +185,29 @@ The `Agent` class defines a few helpful methods to help you understand the inter
 * The `report()` method prints out the agent object’s type, the tools, and the LLMs used for the main agent and tool calling.
 * The `token_counts()` method tells you how many tokens you have used in the current session for both the main agent and tool calling LLMs. This can be helpful if you want to track spend by token.
 
+## Serialization
+
+The `Agent` class supports serialization. Use the `dumps()` to serialize and `loads()` to read back from a serialized stream.
+
+## Observability
+
+vectara-agentic supports observability via the existing integration of LlamaIndex and Arize Phoenix.
+To enable tracing of your vectara-agentic assistant, follow these steps (adapted from [here](https://docs.llamaindex.ai/en/stable/module_guides/observability/)):
+1. Go to `https://llamatrace.com/login` an create an account, then create an API key and put it in the `PHOENIX_API_KEY` variable
+2. `os["VECTARA_AGENTIC_OBSERVER_TYPE"] = "ARIZE_PHOENIX"`: to enable Arize Phoenix observability
+3. `os.environ["OTEL_EXPORTER_OTLP_HEADERS"] = f"api_key={PHOENIX_API_KEY}"`
+
+Now when you run your agent, all metrics are sent to LlamaTrace and recorded. You can view them at `https://llamatrace.com`.
+If you do not include the `OTEL_EXPORTER_OTLP_HEADERS` a local instance of Arize Phoenix will be setup instead and you can view it at `http://localhost:6006`
+
+## About Custom Instructions
+
+The custom instructions you provide to the agent guide its behavior.
+Here are some guidelines when creating your instructions:
+- Write precise and clear instructions, without overcomplicating.
+- Consider edge cases and unusual or atypical scenarios.
+- Be cautious to not over-specify behavior based on your primary use-case, as it may limit the agent's ability to behave properly in others.
+
 ## Examples
 
 Check out our example AI assistants:

vectara_agentic-0.1.10.dist-info/RECORD

@@ -0,0 +1,13 @@
+vectara_agentic/__init__.py,sha256=K7BcM2qRPyrdggQvXrdcPkharv0_8k763NZI3icrGxw,449
+vectara_agentic/_callback.py,sha256=_o8XK1gBmsqpsJACAdJtbtnOnhLe6ZbGahCgb3WMuJQ,3674
+vectara_agentic/_prompts.py,sha256=UV03GBdz0LplkyOacJyBLbrBpWSqUS7iRtM5xmJ0BVU,4572
+vectara_agentic/agent.py,sha256=N3FUcpvrCcnORNw57HVDAtPi_cMqqxOr7po37ybSONA,19696
+vectara_agentic/tools.py,sha256=1-1GmOQPrxbS6kumFrco2kGheIz0f19sgzPtb_-GjIU,19071
+vectara_agentic/tools_catalog.py,sha256=RByoXkF1GhY0rPQGLIeiqQo-j7o1h3lA6KY55ZM9mGg,4448
+vectara_agentic/types.py,sha256=lTL3Is5W7IFyTKuEKu_VKaAsmVFVzKss_y184ayLti8,1080
+vectara_agentic/utils.py,sha256=x8nBncooXHm6gXH-A77TRVzoPGoGleO5VeYi2fVRAA4,3340
+vectara_agentic-0.1.10.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+vectara_agentic-0.1.10.dist-info/METADATA,sha256=vopWHXs1wXL6_-6d2-RfeKq4ilGRr5uZfouy8MzTeXE,10882
+vectara_agentic-0.1.10.dist-info/WHEEL,sha256=R0nc6qTxuoLk7ShA2_Y-UWkN8ZdfDBG2B6Eqpz2WXbs,91
+vectara_agentic-0.1.10.dist-info/top_level.txt,sha256=qT7JB9Xz7byehzlPd_rY4WWEAvPMhs63WMWgPsFthxU,16
+vectara_agentic-0.1.10.dist-info/RECORD,,

vectara_agentic-0.1.8.dist-info/RECORD

@@ -1,13 +0,0 @@
-vectara_agentic/__init__.py,sha256=qTixMQRPaRskeYlbYekridToyBvm5AN3ptDPATgwYlo,448
-vectara_agentic/_callback.py,sha256=_o8XK1gBmsqpsJACAdJtbtnOnhLe6ZbGahCgb3WMuJQ,3674
-vectara_agentic/_prompts.py,sha256=hoNiZLHDIuejunLkzXFcK562KFqGt60McoxU0BTkvgU,4461
-vectara_agentic/agent.py,sha256=rNB3nr_RZWVkiz6xZvTRdfFKtu3sUOxjze284d6yFjw,12195
-vectara_agentic/tools.py,sha256=GmGSpncxSwwBR-LHaG7XrVHVoGxQlveAjRQRArgD3Pk,17725
-vectara_agentic/tools_catalog.py,sha256=RByoXkF1GhY0rPQGLIeiqQo-j7o1h3lA6KY55ZM9mGg,4448
-vectara_agentic/types.py,sha256=lTL3Is5W7IFyTKuEKu_VKaAsmVFVzKss_y184ayLti8,1080
-vectara_agentic/utils.py,sha256=x8nBncooXHm6gXH-A77TRVzoPGoGleO5VeYi2fVRAA4,3340
-vectara_agentic-0.1.8.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-vectara_agentic-0.1.8.dist-info/METADATA,sha256=4WjHI_D1V9IAuG8REULeELHc-0SZEsETHmgGKqldiyE,9273
-vectara_agentic-0.1.8.dist-info/WHEEL,sha256=R0nc6qTxuoLk7ShA2_Y-UWkN8ZdfDBG2B6Eqpz2WXbs,91
-vectara_agentic-0.1.8.dist-info/top_level.txt,sha256=qT7JB9Xz7byehzlPd_rY4WWEAvPMhs63WMWgPsFthxU,16
-vectara_agentic-0.1.8.dist-info/RECORD,,