vectara-agentic 0.1.15__py3-none-any.whl → 0.1.16__py3-none-any.whl

vectara_agentic/tools.py

@@ -18,13 +18,7 @@ from llama_index.core.tools.types import ToolMetadata, ToolOutput
 
 
 from .types import ToolType
-from .tools_catalog import (
-    summarize_text,
-    rephrase_text,
-    critique_text,
-    get_bad_topics,
-    db_load_sample_data
-)
+from .tools_catalog import summarize_text, rephrase_text, critique_text, get_bad_topics, DBLoadSampleData
 
 LI_packages = {
     "yahoo_finance": ToolType.QUERY,
@@ -51,24 +45,42 @@ LI_packages = {
 }
 
 
+class VectaraToolMetadata(ToolMetadata):
+    """
+    A subclass of ToolMetadata adding the tool_type attribute.
+    """
+    tool_type: ToolType
+
+    def __init__(self, tool_type: ToolType, **kwargs):
+        super().__init__(**kwargs)
+        self.tool_type = tool_type
+
+    def __repr__(self) -> str:
+        """
+        Returns a string representation of the VectaraToolMetadata object, including the tool_type attribute.
+        """
+        base_repr = super().__repr__()
+        return f"{base_repr}, tool_type={self.tool_type}"
+
 class VectaraTool(FunctionTool):
     """
     A subclass of FunctionTool adding the tool_type attribute.
     """
+
     def __init__(
         self,
         tool_type: ToolType,
+        metadata: ToolMetadata,
         fn: Optional[Callable[..., Any]] = None,
-        metadata: Optional[ToolMetadata] = None,
         async_fn: Optional[AsyncCallable] = None,
     ) -> None:
-        self.tool_type = tool_type
-        super().__init__(fn, metadata, async_fn)
+        metadata_dict = metadata.dict() if hasattr(metadata, 'dict') else metadata.__dict__
+        vm = VectaraToolMetadata(tool_type=tool_type, **metadata_dict)
+        super().__init__(fn, vm, async_fn)
 
     @classmethod
     def from_defaults(
         cls,
-        tool_type: ToolType,
         fn: Optional[Callable[..., Any]] = None,
         name: Optional[str] = None,
         description: Optional[str] = None,
@@ -76,18 +88,14 @@ class VectaraTool(FunctionTool):
         fn_schema: Optional[Type[BaseModel]] = None,
         async_fn: Optional[AsyncCallable] = None,
         tool_metadata: Optional[ToolMetadata] = None,
+        tool_type: ToolType = ToolType.QUERY,
     ) -> "VectaraTool":
         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
-        )
+        vectara_tool = cls(tool_type=tool_type, 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:
+        if self.metadata.tool_type != other.metadata.tool_type:
             return False
 
         # Check if fn_schema is an instance of a BaseModel or a class itself (metaclass)
@@ -98,15 +106,15 @@ class VectaraTool(FunctionTool):
             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()
+            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:
     """
     A factory class for creating Vectara RAG tools.
@@ -145,7 +153,7 @@ class VectaraToolFactory:
         rerank_k: int = 50,
         mmr_diversity_bias: float = 0.2,
         include_citations: bool = True,
-        fcs_threshold: float = 0.0
+        fcs_threshold: float = 0.0,
     ) -> VectaraTool:
         """
         Creates a RAG (Retrieve and Generate) tool.
@@ -175,7 +183,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"
+            x_source_str="vectara-agentic",
         )
 
         def _build_filter_string(kwargs):
@@ -225,7 +233,7 @@ class VectaraToolFactory:
                     tool_name=rag_function.__name__,
                     content=msg,
                     raw_input={"args": args, "kwargs": kwargs},
-                    raw_output={'response': msg}
+                    raw_output={"response": msg},
                 )
             if len(response.source_nodes) == 0:
                 msg = "Tool failed to generate a response since no matches were found."
@@ -233,18 +241,28 @@ class VectaraToolFactory:
                     tool_name=rag_function.__name__,
                     content=msg,
                     raw_input={"args": args, "kwargs": kwargs},
-                    raw_output={'response': msg}
+                    raw_output={"response": msg},
                 )
 
             # Extract citation metadata
             pattern = r"\[(\d+)\]"
             matches = re.findall(pattern, response.response)
-            citation_numbers = sorted(set([int(match) for match in matches]))
+            citation_numbers = sorted(set(int(match) for match in matches))
             citation_metadata = ""
             keys_to_ignore = ["lang", "offset", "len"]
             for citation_number in citation_numbers:
                 metadata = response.source_nodes[citation_number - 1].metadata
-                citation_metadata += f"""[{citation_number}]: {"; ".join([f"{k}='{v}'" for k,v in metadata.items() if k not in keys_to_ignore])}.\n"""
+                citation_metadata += (
+                    f"[{citation_number}]: "
+                    + "; ".join(
+                        [
+                            f"{k}='{v}'"
+                            for k, v in metadata.items()
+                            if k not in keys_to_ignore
+                        ]
+                    )
+                    + ".\n"
+                )
             fcs = response.metadata["fcs"] if "fcs" in response.metadata else 0.0
             if fcs < fcs_threshold:
                 msg = f"Could not answer the query due to suspected hallucination (fcs={fcs})."
@@ -252,7 +270,7 @@ class VectaraToolFactory:
                     tool_name=rag_function.__name__,
                     content=msg,
                     raw_input={"args": args, "kwargs": kwargs},
-                    raw_output={'response': msg}
+                    raw_output={"response": msg},
                 )
             res = {
                 "response": response.response,
@@ -288,16 +306,16 @@ class VectaraToolFactory:
         # 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.__annotations__["return"] = dict[str, Any]
         rag_function.__name__ = "_" + re.sub(r"[^A-Za-z0-9_]", "_", tool_name)
 
         # Create the tool
         tool = VectaraTool.from_defaults(
-            tool_type=ToolType.QUERY,
             fn=rag_function,
             name=tool_name,
             description=tool_description,
             fn_schema=tool_args_schema,
+            tool_type=ToolType.QUERY,
         )
         return tool
 
@@ -307,9 +325,7 @@ class ToolsFactory:
     A factory class for creating agent tools.
     """
 
-    def create_tool(
-        self, function: Callable, tool_type: ToolType = ToolType.QUERY
-    ) -> VectaraTool:
+    def create_tool(self, function: Callable, tool_type: ToolType = ToolType.QUERY) -> VectaraTool:
         """
         Create a tool from a function.
 
@@ -320,7 +336,7 @@ class ToolsFactory:
         Returns:
             VectaraTool: A VectaraTool object.
         """
-        return VectaraTool.from_defaults(tool_type, function)
+        return VectaraTool.from_defaults(tool_type=tool_type, fn=function)
 
     def get_llama_index_tools(
         self,
@@ -342,10 +358,8 @@ class ToolsFactory:
             List[VectaraTool]: A list of VectaraTool objects.
         """
         # Dynamically install and import the module
-        if tool_package_name not in LI_packages.keys():
-            raise ValueError(
-                f"Tool package {tool_package_name} from LlamaIndex not supported by Vectara-agentic."
-            )
+        if tool_package_name not in LI_packages:
+            raise ValueError(f"Tool package {tool_package_name} from LlamaIndex not supported by Vectara-agentic.")
 
         module_name = f"llama_index.tools.{tool_package_name}"
         module = importlib.import_module(module_name)
@@ -358,21 +372,14 @@ class ToolsFactory:
         vtools = []
         for tool in tools:
             if len(tool_name_prefix) > 0:
-                tool._metadata.name = tool_name_prefix + "_" + tool._metadata.name
+                tool.metadata.name = tool_name_prefix + "_" + tool.metadata.name
             if isinstance(func_type, dict):
                 if tool_spec_name not in func_type.keys():
-                    raise ValueError(
-                        f"Tool spec {tool_spec_name} not found in package {tool_package_name}."
-                    )
+                    raise ValueError(f"Tool spec {tool_spec_name} not found in package {tool_package_name}.")
                 tool_type = func_type[tool_spec_name]
             else:
                 tool_type = func_type
-            vtool = VectaraTool(
-                tool_type=tool_type,
-                fn=tool.fn,
-                metadata=tool.metadata,
-                async_fn=tool.async_fn
-            )
+            vtool = VectaraTool(tool_type=tool_type, fn=tool.fn, metadata=tool.metadata, async_fn=tool.async_fn)
             vtools.append(vtool)
         return vtools
 
@@ -386,23 +393,19 @@ class ToolsFactory:
         """
         Create a list of guardrail tools to avoid controversial topics.
         """
-        return [
-            self.create_tool(get_bad_topics)
-        ]
+        return [self.create_tool(get_bad_topics)]
 
     def financial_tools(self):
         """
         Create a list of financial tools.
         """
-        return self.get_llama_index_tools(
-            tool_package_name="yahoo_finance",
-            tool_spec_name="YahooFinanceToolSpec"
-        )
+        return self.get_llama_index_tools(tool_package_name="yahoo_finance", tool_spec_name="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:
@@ -426,9 +429,7 @@ class ToolsFactory:
                 """,
             )
 
-        return [
-            self.create_tool(tool) for tool in [summarize_legal_text, critique_as_judge]
-        ]
+        return [self.create_tool(tool) for tool in [summarize_legal_text, critique_as_judge]]
 
     def database_tools(
         self,
@@ -482,18 +483,21 @@ class ToolsFactory:
                     dbname=dbname,
                 )
             else:
-                raise Exception("Please provide a SqlDatabase option or a valid DB scheme type (postgresql, mysql, sqlite, mssql, oracle).")
+                raise ValueError(
+                    "Please provide a SqlDatabase option or a valid DB scheme type "
+                    " (postgresql, mysql, sqlite, mssql, oracle)."
+                )
 
         # Update tools with description
         for tool in tools:
             if content_description:
-                tool._metadata.description = (
-                    tool._metadata.description
-                    + f"The database tables include data about {content_description}."
+                tool.metadata.description = (
+                    tool.metadata.description + f"The database tables include data about {content_description}."
                 )
 
-        load_data_tool = [t for t in tools if t._metadata.name.endswith("load_data")][0]
-        sample_data_fn = db_load_sample_data(load_data_tool)
+        # Update load_data_tool to return only text instead of "Document" objects (to save on space)
+        load_data_tool_index = next(i for i, t in enumerate(tools) if t.metadata.name.endswith("load_data"))
+        sample_data_fn = DBLoadSampleData(tools[load_data_tool_index])
         sample_data_fn.__name__ = f"{tool_name_prefix}_load_sample_data"
         sample_data_tool = self.create_tool(sample_data_fn, ToolType.QUERY)
         tools.append(sample_data_tool)

vectara_agentic/tools_catalog.py

@@ -2,10 +2,10 @@
 This module contains the tools catalog for the Vectara Agentic.
 """
 
-from typing import Optional, Callable, Any, List
+from typing import Callable, Any, List
+from functools import lru_cache
 from pydantic import Field
 import requests
-from functools import lru_cache
 
 from .types import LLMRole
 from .utils import get_llm
@@ -24,7 +24,7 @@ get_headers = {
 #
 # Standard Tools
 #
-@lru_cache(maxsize=5)
+@lru_cache(maxsize=None)
 def summarize_text(
     text: str = Field(description="the original text."),
     expertise: str = Field(
@@ -55,12 +55,11 @@ def summarize_text(
     response = llm.complete(prompt)
     return response.text
 
-@lru_cache(maxsize=5)
+
+@lru_cache(maxsize=None)
 def rephrase_text(
     text: str = Field(description="the original text."),
-    instructions: str = Field(
-        description="the specific instructions for how to rephrase the text."
-    ),
+    instructions: str = Field(description="the specific instructions for how to rephrase the text."),
 ) -> str:
     """
     This is a helper tool.
@@ -84,15 +83,12 @@ def rephrase_text(
     response = llm.complete(prompt)
     return response.text
 
-@lru_cache(maxsize=5)
+
+@lru_cache(maxsize=None)
 def critique_text(
     text: str = Field(description="the original text."),
-    role: Optional[str] = Field(
-        None, description="the role of the person providing critique."
-    ),
-    point_of_view: Optional[str] = Field(
-        None, description="the point of view with which to provide critique."
-    ),
+    role: str = Field(default=None, description="the role of the person providing critique."),
+    point_of_view: str = Field(default=None, description="the point of view with which to provide critique."),
 ) -> str:
     """
     This is a helper tool.
@@ -109,9 +105,7 @@ def critique_text(
     if role:
         prompt = f"As a {role}, critique the provided text from the point of view of {point_of_view}."
     else:
-        prompt = (
-            f"Critique the provided text from the point of view of {point_of_view}."
-        )
+        prompt = f"Critique the provided text from the point of view of {point_of_view}."
     prompt += "Structure the critique as bullet points.\n"
     prompt += f"Original text: {text}\nCritique:"
     llm = get_llm(LLMRole.TOOL)
@@ -126,21 +120,30 @@ def get_bad_topics() -> List[str]:
     """
     Get the list of topics to avoid in the response.
     """
-    return ["politics", "religion", "violence", "hate speech", "adult content", "illegal activities"]
+    return [
+        "politics",
+        "religion",
+        "violence",
+        "hate speech",
+        "adult content",
+        "illegal activities",
+    ]
+
 
 #
 # Additional database tool
 #
-class db_load_sample_data:
+class DBLoadSampleData:
     """
     A tool to load a sample of data from the specified database table.
 
-    This tool fetches the first num_rows (default 25) rows from the given table using a provided database query function.
+    This tool fetches the first num_rows (default 25) rows from the given table
+    using a provided database query function.
     """
 
     def __init__(self, load_data_tool: Callable):
         """
-        Initializes the db_load_sample_data with the provided load_data_tool function.
+        Initializes the DBLoadSampleData object with the provided load_data_tool function.
 
         Args:
             load_data_tool (Callable): A function to execute the SQL query.

vectara_agentic/types.py

@@ -11,7 +11,6 @@ class AgentType(Enum):
     OPENAI = "OPENAI"
     LLMCOMPILER = "LLMCOMPILER"
 
-
 class ObserverType(Enum):
     """Enumeration for different types of observability integrations."""
 

vectara_agentic/utils.py

@@ -3,8 +3,10 @@ Utilities for the Vectara agentic.
 """
 
 import os
-import tiktoken
 from typing import Tuple, Callable, Optional
+from functools import lru_cache
+
+import tiktoken
 
 from llama_index.core.llms import LLM
 from llama_index.llms.openai import OpenAI
@@ -24,11 +26,12 @@ provider_to_default_model_name = {
 
 DEFAULT_MODEL_PROVIDER = ModelProvider.OPENAI
 
+@lru_cache(maxsize=None)
 def _get_llm_params_for_role(role: LLMRole) -> Tuple[ModelProvider, 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)
+            os.getenv("VECTARA_AGENTIC_TOOL_LLM_PROVIDER", str(DEFAULT_MODEL_PROVIDER))
         )
         model_name = os.getenv(
             "VECTARA_AGENTIC_TOOL_MODEL_NAME",
@@ -36,14 +39,16 @@ def _get_llm_params_for_role(role: LLMRole) -> Tuple[ModelProvider, str]:
         )
     else:
         model_provider = ModelProvider(
-            os.getenv("VECTARA_AGENTIC_MAIN_LLM_PROVIDER", DEFAULT_MODEL_PROVIDER)
+            os.getenv("VECTARA_AGENTIC_MAIN_LLM_PROVIDER", str(DEFAULT_MODEL_PROVIDER))
         )
         model_name = os.getenv(
             "VECTARA_AGENTIC_MAIN_MODEL_NAME",
             provider_to_default_model_name.get(model_provider),
         )
 
-    agent_type = AgentType(os.getenv("VECTARA_AGENTIC_AGENT_TYPE", AgentType.OPENAI))
+    agent_type = AgentType(
+        os.getenv("VECTARA_AGENTIC_AGENT_TYPE", str(AgentType.OPENAI))
+    )
     if (
         role == LLMRole.MAIN
         and agent_type == AgentType.OPENAI
@@ -55,18 +60,18 @@ def _get_llm_params_for_role(role: LLMRole) -> Tuple[ModelProvider, str]:
 
     return model_provider, model_name
 
-
+@lru_cache(maxsize=None)
 def get_tokenizer_for_model(role: LLMRole) -> Optional[Callable]:
     """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:
+    if model_provider == ModelProvider.ANTHROPIC:
         return Anthropic().tokenizer
-    else:
-        return None
+    return None
 
 
+@lru_cache(maxsize=None)
 def get_llm(role: LLMRole) -> LLM:
     """Get the LLM for the specified role."""
     model_provider, model_name = _get_llm_params_for_role(role)
@@ -74,7 +79,7 @@ def get_llm(role: LLMRole) -> LLM:
     if model_provider == ModelProvider.OPENAI:
         llm = OpenAI(model=model_name, temperature=0, is_function_calling_model=True)
     elif model_provider == ModelProvider.ANTHROPIC:
-        llm = Anthropic(model=model_name, temperature=0, is_function_calling_model=True)
+        llm = Anthropic(model=model_name, temperature=0)
     elif model_provider == ModelProvider.GEMINI:
         from llama_index.llms.gemini import Gemini
         llm = Gemini(model=model_name, temperature=0, is_function_calling_model=True)
@@ -86,10 +91,10 @@ def get_llm(role: LLMRole) -> LLM:
         llm = Groq(model=model_name, temperature=0, is_function_calling_model=True)
     elif model_provider == ModelProvider.FIREWORKS:
         from llama_index.llms.fireworks import Fireworks
-        llm = Fireworks(model=model_name, temperature=0, is_function_calling_model=True)
+        llm = Fireworks(model=model_name, temperature=0)
     elif model_provider == ModelProvider.COHERE:
         from llama_index.llms.cohere import Cohere
-        llm = Cohere(model=model_name, temperature=0, is_function_calling_model=True)
+        llm = Cohere(model=model_name, temperature=0)
     else:
         raise ValueError(f"Unknown LLM provider: {model_provider}")
 

{vectara_agentic-0.1.15.dist-info → vectara_agentic-0.1.16.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vectara_agentic
-Version: 0.1.15
+Version: 0.1.16
 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
@@ -16,17 +16,17 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: llama-index==0.11.13
+Requires-Dist: llama-index==0.11.18
 Requires-Dist: llama-index-indices-managed-vectara==0.2.2
 Requires-Dist: llama-index-agent-llm-compiler==0.2.0
 Requires-Dist: llama-index-agent-openai==0.3.4
-Requires-Dist: llama-index-llms-openai==0.2.9
-Requires-Dist: llama-index-llms-anthropic==0.3.1
+Requires-Dist: llama-index-llms-openai==0.2.15
+Requires-Dist: llama-index-llms-anthropic==0.3.6
 Requires-Dist: llama-index-llms-together==0.2.0
 Requires-Dist: llama-index-llms-groq==0.2.0
-Requires-Dist: llama-index-llms-fireworks==0.2.0
-Requires-Dist: llama-index-llms-cohere==0.3.0
-Requires-Dist: llama-index-llms-gemini==0.3.5
+Requires-Dist: llama-index-llms-fireworks==0.2.2
+Requires-Dist: llama-index-llms-cohere==0.3.1
+Requires-Dist: llama-index-llms-gemini==0.3.7
 Requires-Dist: llama-index-tools-yahoo-finance==0.2.0
 Requires-Dist: llama-index-tools-arxiv==0.2.0
 Requires-Dist: llama-index-tools-database==0.2.0
@@ -68,13 +68,29 @@ Requires-Dist: dill==0.3.8
 
 ## ✨ Overview
 
-`vectara-agentic` is a Python library for developing powerful AI assistants using Vectara and Agentic-RAG. It leverages the LlamaIndex Agent framework, customized for use with Vectara.
+`vectara-agentic` is a Python library for developing powerful AI assistants and agents using Vectara and Agentic-RAG. It leverages the LlamaIndex Agent framework, customized for use with Vectara.
 
-###  Key Features
+<p align="center">
+<img src="https://raw.githubusercontent.com/vectara/py-vectara-agentic/main/.github/assets/diagram1.png" alt="Agentic RAG diagram" width="100%" style="vertical-align: middle;">
+</p>
+
+###  Features
 
+- Enables easy creation of custom AI assistants and agents.
+- Create a Vectara RAG tool with a single line of code.
 - Supports `ReAct`, `OpenAIAgent` and `LLMCompiler` agent types.
 - Includes pre-built tools for various domains (e.g., finance, legal).
-- Enables easy creation of custom AI assistants and agents.
+- Integrates with various LLM inference services like OpenAI, Anthropic, Gemini, GROQ, Together.AI, Cohere and Fireworks
+- Built-in support for observability with Arize Phoenix
+
+### 📚 Example AI Assistants
+
+Check out our example AI assistants:
+
+- [Financial Assistant](https://huggingface.co/spaces/vectara/finance-chat)
+- [Justice Harvard Teaching Assistant](https://huggingface.co/spaces/vectara/Justice-Harvard)
+- [Legal Assistant](https://huggingface.co/spaces/vectara/legal-agent)
+
 
 ###  Prerequisites
 
@@ -197,7 +213,15 @@ When creating a VectaraToolFactory, you can pass in a `vectara_api_key`, `vectar
 
 ## ℹ️ Additional Information
 
-###  Agent Diagnostics
+### About Custom Instructions for your Agent
+
+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.
+
+###  Diagnostics
 
 The `Agent` class defines a few helpful methods to help you understand the internals of your application. 
 * The `report()` method prints out the agent object’s type, the tools, and the LLMs used for the main agent and tool calling.
@@ -224,21 +248,43 @@ Then you can use Arize Phoenix in three ways:
 Now when you run your agent, all call traces are sent to Phoenix and recorded. 
 In addition, vectara-agentic also records `FCS` (factual consistency score, aka HHEM) values into Arize for every Vectara RAG call. You can see those results in the `Feedback` column of the arize UI.
 
-### About Custom Instructions
+## 🌐 API Endpoint
 
-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.
+`vectara-agentic` can be easily hosted locally or on a remote machine behind an API endpoint, by following theses steps:
 
-## 📚 Examples
+### Step 1: Setup your API key
+Ensure that you have your API key set up as an environment variable:
 
-Check out our example AI assistants:
+```
+export VECTARA_AGENTIC_API_KEY=<YOUR-ENDPOINT-API-KEY>
+```
 
-- [Financial Assistant](https://huggingface.co/spaces/vectara/finance-chat)
-- [Justice Harvard Teaching Assistant](https://huggingface.co/spaces/vectara/Justice-Harvard)
-- [Legal Assistant](https://huggingface.co/spaces/vectara/legal-agent)
+### Step 2: Start the API Server
+Initialize the agent and start the FastAPI server by following this example:
+
+
+```
+from agent import Agent
+from agent_endpoint import start_app
+agent = Agent(...)            # Initialize your agent with appropriate parameters
+start_app(agent)
+```
+
+You can customize the host and port by passing them as arguments to `start_app()`:
+* Default: host="0.0.0.0" and port=8000.
+For example:
+```
+start_app(agent, host="0.0.0.0", port=8000)
+```
+
+### Step 3: Access the API Endpoint
+Once the server is running, you can interact with it using curl or any HTTP client. For example:
+
+```
+curl -G "http://<remote-server-ip>:8000/chat" \
+--data-urlencode "message=What is Vectara?" \
+-H "X-API-Key: <YOUR-API-KEY>"
+```
 
 ## 🤝 Contributing
 

vectara_agentic-0.1.16.dist-info/RECORD

@@ -0,0 +1,18 @@
+tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/test_agent.py,sha256=aQYYr_8hKlFiDgyI5Dd39TG5vkmDJe7F_nIzMTCLsTQ,2517
+tests/test_tools.py,sha256=hDAlXkWKuXHnAjeQwMuTLTwNdRsM-xR7muBzFkZRefw,2942
+vectara_agentic/__init__.py,sha256=ZlASMUqOFi5HTDFaRUEB3Egf_nUuUtr1X-TjPkZceLc,508
+vectara_agentic/_callback.py,sha256=EexD7-Qx2lZuQk4kjzwvIJAyfIzroWKz2VaVPD4TTkM,4621
+vectara_agentic/_observability.py,sha256=v0xxTk8KI8nVK2rpyGqOVhyva9ymqOmZK5brKqFOwMM,3828
+vectara_agentic/_prompts.py,sha256=CxSKueS4lF130VMSovFKeapTM9DZ8Ja4akEFIw7q0Ks,5670
+vectara_agentic/agent.py,sha256=9nzPVb16wpeT5RiWQJiO5LuR9VTYp8yScKUqqgem7h8,19963
+vectara_agentic/agent_endpoint.py,sha256=I3zTEezbAiNeW5I41r0NjIaR8Ucn4oe1XVcALekakaA,1959
+vectara_agentic/tools.py,sha256=_rXEK9tuuDMM_Zf04AoehklydTMSb1esqEYkNjLvmyY,20103
+vectara_agentic/tools_catalog.py,sha256=CpFTTyocsTu-Sx8KjqSsZZhLditSrV-vRZd2YMFU0AY,4940
+vectara_agentic/types.py,sha256=FbZXc5oPje6kdimfrksDc8F-tYHSLK8ReAv7O291YkI,1131
+vectara_agentic/utils.py,sha256=7DgzU_hZIODrzuEfP8HP7l2dO9zEt8BObhO2tCTijow,3819
+vectara_agentic-0.1.16.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+vectara_agentic-0.1.16.dist-info/METADATA,sha256=QYMmXzZBZwLvgr9rcx4dt0aE-upuJ3mqlJi7v5vt0T0,13595
+vectara_agentic-0.1.16.dist-info/WHEEL,sha256=OVMc5UfuAQiSplgO0_WdW7vXVGAt9Hdd6qtN4HotdyA,91
+vectara_agentic-0.1.16.dist-info/top_level.txt,sha256=Y7TQTFdOYGYodQRltUGRieZKIYuzeZj2kHqAUpfCUfg,22
+vectara_agentic-0.1.16.dist-info/RECORD,,

{vectara_agentic-0.1.15.dist-info → vectara_agentic-0.1.16.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.1.0)
+Generator: setuptools (75.2.0)
 Root-Is-Purelib: true
 Tag: py3-none-any