vectara-agentic 0.2.0__py3-none-any.whl → 0.2.1__py3-none-any.whl

tests/endpoint.py

@@ -0,0 +1,42 @@
+from openai import OpenAI
+from flask import Flask, request, jsonify
+from functools import wraps
+
+app = Flask(__name__)
+
+# Set your OpenAI API key (ensure you've set this in your environment)
+
+EXPECTED_API_KEY = "TEST_API_KEY"
+
+def require_api_key(f):
+    @wraps(f)
+    def decorated_function(*args, **kwargs):
+        api_key = request.headers.get("Authorization").split("Bearer ")[-1]
+        if not api_key or api_key != EXPECTED_API_KEY:
+            return jsonify({"error": "Unauthorized"}), 401
+        return f(*args, **kwargs)
+    return decorated_function
+
+@app.before_request
+def log_request_info():
+    app.logger.info("Request received: %s %s", request.method, request.path)
+
+@app.route("/v1/chat/completions", methods=["POST"])
+@require_api_key
+def chat_completions():
+    app.logger.info("Received request on /v1/chat/completions")
+    data = request.get_json()
+    if not data:
+        return jsonify({"error": "Invalid JSON payload"}), 400
+
+    client = OpenAI()
+    try:
+        completion = client.chat.completions.create(**data)
+        return jsonify(completion.model_dump()), 200
+    except Exception as e:
+        return jsonify({"error": str(e)}), 400
+
+
+if __name__ == "__main__":
+    # Run on port 5000 by default; adjust as needed.
+    app.run(debug=True, port=5000)

tests/test_agent.py

@@ -77,6 +77,24 @@ class TestAgentPackage(unittest.TestCase):
             "50",
         )
 
+    def test_multiturn(self):
+        def mult(x, y):
+            return x * y
+
+        tools = [ToolsFactory().create_tool(mult)]
+        topic = "AI topic"
+        instructions = "Always do as your father tells you, if your mother agrees!"
+        agent = Agent(
+            tools=tools,
+            topic=topic,
+            custom_instructions=instructions,
+        )
+
+        agent.chat("What is 5 times 10. Only give the answer, nothing else")
+        agent.chat("what is 3 times 7. Only give the answer, nothing else")
+        res = agent.chat("multiply the results of the last two questions. Output only the answer.")
+        self.assertEqual(res.response, "1050")
+
     def test_from_corpus(self):
         agent = Agent.from_corpus(
             tool_name="RAG Tool",
@@ -99,8 +117,15 @@ class TestAgentPackage(unittest.TestCase):
         )
 
         agent_reloaded = agent.loads(agent.dumps())
+        agent_reloaded_again = agent_reloaded.loads(agent_reloaded.dumps())
+
         self.assertIsInstance(agent_reloaded, Agent)
         self.assertEqual(agent, agent_reloaded)
+        self.assertEqual(agent.agent_type, agent_reloaded.agent_type)
+
+        self.assertIsInstance(agent_reloaded, Agent)
+        self.assertEqual(agent, agent_reloaded_again)
+        self.assertEqual(agent.agent_type, agent_reloaded_again.agent_type)
 
 
 if __name__ == "__main__":

tests/test_private_llm.py

@@ -0,0 +1,67 @@
+import os
+import unittest
+import subprocess
+import time
+import requests
+import signal
+
+from vectara_agentic.agent import Agent, AgentType
+from vectara_agentic.agent_config import AgentConfig
+from vectara_agentic.types import ModelProvider
+from vectara_agentic.tools import ToolsFactory
+
+class TestPrivateLLM(unittest.TestCase):
+
+    @classmethod
+    def setUp(cls):
+        # Start the Flask server as a subprocess
+        cls.flask_process = subprocess.Popen(
+            ['flask', 'run', '--port=5000'],
+            env={**os.environ, 'FLASK_APP': 'tests.endpoint:app', 'FLASK_ENV': 'development'},
+            stdout=None, stderr=None,
+        )
+        # Wait for the server to start
+        timeout = 10
+        url = 'http://127.0.0.1:5000/'
+        for _ in range(timeout):
+            try:
+                requests.get(url)
+                return
+            except requests.ConnectionError:
+                time.sleep(1)
+        raise RuntimeError(f"Failed to start Flask server at {url}")
+
+    @classmethod
+    def tearDown(cls):
+        # Terminate the Flask server
+        cls.flask_process.send_signal(signal.SIGINT)
+        cls.flask_process.wait()
+
+    def test_endpoint(self):
+        def mult(x, y):
+            return x * y
+
+        tools = [ToolsFactory().create_tool(mult)]
+        topic = "calculator"
+        custom_instructions = "you are an agent specializing in math, assisting a user."
+        config = AgentConfig(
+            agent_type=AgentType.REACT,
+            main_llm_provider=ModelProvider.PRIVATE,
+            main_llm_model_name="gpt-4o",
+            private_llm_api_base="http://127.0.0.1:5000/v1",
+            private_llm_api_key="TEST_API_KEY",
+        )
+        agent = Agent(agent_config=config, tools=tools, topic=topic,
+                      custom_instructions=custom_instructions)
+
+        # To run this test, you must have OPENAI_API_KEY in your environment
+        self.assertEqual(
+            agent.chat(
+                "What is 5 times 10. Only give the answer, nothing else"
+            ).response.replace("$", "\\$"),
+            "50",
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_tools.py

@@ -1,8 +1,11 @@
 import unittest
 
+from pydantic import Field, BaseModel
+
 from vectara_agentic.tools import VectaraTool, VectaraToolFactory, ToolsFactory, ToolType
 from vectara_agentic.agent import Agent
-from pydantic import Field, BaseModel
+from vectara_agentic.agent_config import AgentConfig
+
 from llama_index.core.tools import FunctionTool
 
 
@@ -60,9 +63,6 @@ class TestToolsPackage(unittest.TestCase):
         vectara_corpus_key = "vectara-docs_1"
         vectara_api_key = "zqt_UXrBcnI2UXINZkrv4g1tQPhzj02vfdtqYJIDiA"
 
-        class QueryToolArgs(BaseModel):
-            query: str = Field(description="The user query")
-
         agent = Agent.from_corpus(
             vectara_corpus_key=vectara_corpus_key,
             vectara_api_key=vectara_api_key,
@@ -72,7 +72,34 @@ class TestToolsPackage(unittest.TestCase):
             vectara_summarizer="mockingbird-1.0-2024-07-16"
         )
 
-        self.assertIn("Vectara is an end-to-end platform", agent.chat("What is Vectara?"))
+        self.assertIn("Vectara is an end-to-end platform", str(agent.chat("What is Vectara?")))
+
+    def test_class_method_as_tool(self):
+        class TestClass:
+            def __init__(self):
+                pass
+
+            def mult(self, x, y):
+                return x * y
+
+        test_class = TestClass()
+        tools = [ToolsFactory().create_tool(test_class.mult)]
+        topic = "AI topic"
+        instructions = "Always do as your father tells you, if your mother agrees!"
+        config = AgentConfig()
+        agent = Agent(
+            tools=tools,
+            topic=topic,
+            custom_instructions=instructions,
+            agent_config=config
+        )
+
+        self.assertEqual(
+            agent.chat(
+                "What is 5 times 10. Only give the answer, nothing else"
+            ).response.replace("$", "\\$"),
+            "50",
+        )
 
 
 if __name__ == "__main__":

vectara_agentic/_prompts.py

@@ -5,7 +5,9 @@ This file contains the prompt templates for the different types of agents.
 # General (shared) instructions
 GENERAL_INSTRUCTIONS = """
 - Use tools as your main source of information, do not respond without using a tool. Do not respond based on pre-trained knowledge.
-- Always call the 'get_current_date' tool to ensure you know the exact date when a user asks a question.
+- Before responding to a user query that requires knowledge of the current date, call the 'get_current_date' tool to get the current date.
+  Never rely on previous knowledge of the current date.
+  Example queries that require the current date: "What is the revenue of Apple last october?" or "What was the stock price 5 days ago?".
 - When using a tool with arguments, simplify the query as much as possible if you use the tool with arguments.
   For example, if the original query is "revenue for apple in 2021", you can use the tool with a query "revenue" with arguments year=2021 and company=apple.
 - If a tool responds with "I do not have enough information", try one of the following:

vectara_agentic/_version.py

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

vectara_agentic/agent.py

@@ -1,8 +1,9 @@
 """
 This module contains the Agent class for handling different types of agents and their interactions.
 """
-from typing import List, Callable, Optional, Dict, Any
+from typing import List, Callable, Optional, Dict, Any, Union, Tuple
 import os
+import re
 from datetime import date
 import time
 import json
@@ -10,12 +11,15 @@ import logging
 import traceback
 import asyncio
 
-import dill
+import cloudpickle as pickle
+
 from dotenv import load_dotenv
 
 from retrying import retry
 from pydantic import Field, create_model
 
+from llama_index.core.memory import ChatMemoryBuffer
+from llama_index.core.llms import ChatMessage, MessageRole
 from llama_index.core.tools import FunctionTool
 from llama_index.core.agent import ReActAgent
 from llama_index.core.agent.react.formatter import ReActChatFormatter
@@ -24,7 +28,7 @@ from llama_index.agent.lats import LATSAgentWorker
 from llama_index.core.callbacks import CallbackManager, TokenCountingHandler
 from llama_index.core.callbacks.base_handler import BaseCallbackHandler
 from llama_index.agent.openai import OpenAIAgent
-from llama_index.core.memory import ChatMemoryBuffer
+
 
 from .types import AgentType, AgentStatusType, LLMRole, ToolType, AgentResponse, AgentStreamingResponse
 from .utils import get_llm, get_tokenizer_for_model
@@ -35,6 +39,21 @@ from .tools import VectaraToolFactory, VectaraTool, ToolsFactory
 from .tools_catalog import get_current_date
 from .agent_config import AgentConfig
 
+class IgnoreUnpickleableAttributeFilter(logging.Filter):
+    '''
+    Filter to ignore log messages that contain certain strings
+    '''
+    def filter(self, record):
+        msgs_to_ignore = [
+            "Removing unpickleable private attribute _chunking_tokenizer_fn",
+            "Removing unpickleable private attribute _split_fns",
+            "Removing unpickleable private attribute _sub_sentence_split_fns",
+        ]
+        return all(msg not in record.getMessage() for msg in msgs_to_ignore)
+
+
+logging.getLogger().addFilter(IgnoreUnpickleableAttributeFilter())
+
 logger = logging.getLogger("opentelemetry.exporter.otlp.proto.http.trace_exporter")
 logger.setLevel(logging.CRITICAL)
 
@@ -81,6 +100,34 @@ def _retry_if_exception(exception):
     return isinstance(exception, (TimeoutError))
 
 
+def get_field_type(field_schema: dict) -> Any:
+    """
+    Convert a JSON schema field definition to a Python type.
+    Handles 'type' and 'anyOf' cases.
+    """
+    json_type_to_python = {
+        "string": str,
+        "integer": int,
+        "boolean": bool,
+        "array": list,
+        "object": dict,
+        "number": float,
+    }
+    if "anyOf" in field_schema:
+        types = []
+        for option in field_schema["anyOf"]:
+            # If the option has a type, convert it; otherwise, use Any.
+            if "type" in option:
+                types.append(json_type_to_python.get(option["type"], Any))
+            else:
+                types.append(Any)
+        # Return a Union of the types. For example, Union[str, int]
+        return Union[tuple(types)]
+    elif "type" in field_schema:
+        return json_type_to_python.get(field_schema["type"], Any)
+    else:
+        return Any
+
 class Agent:
     """
     Agent class for handling different types of agents and their interactions.
@@ -96,6 +143,7 @@ class Agent:
         agent_progress_callback: Optional[Callable[[AgentStatusType, str], None]] = None,
         query_logging_callback: Optional[Callable[[str, str], None]] = None,
         agent_config: Optional[AgentConfig] = None,
+        chat_history: Optional[list[Tuple[str, str]]] = None,
     ) -> None:
         """
         Initialize the agent with the specified type, tools, topic, and system message.
@@ -111,10 +159,13 @@ class Agent:
             query_logging_callback (Callable): A callback function the code calls upon completion of a query
             agent_config (AgentConfig, optional): The configuration of the agent.
                 Defaults to AgentConfig(), which reads from environment variables.
+            chat_history (Tuple[str, str], optional): A list of user/agent chat pairs to initialize the agent memory.
         """
         self.agent_config = agent_config or AgentConfig()
         self.agent_type = self.agent_config.agent_type
-        self.tools = tools + [ToolsFactory().create_tool(get_current_date)]
+        self.tools = tools
+        if not any(tool.metadata.name == 'get_current_date' for tool in self.tools):
+            self.tools += [ToolsFactory().create_tool(get_current_date)]
         self.llm = get_llm(LLMRole.MAIN, config=self.agent_config)
         self._custom_instructions = custom_instructions
         self._topic = topic
@@ -135,7 +186,14 @@ class Agent:
         self.llm.callback_manager = callback_manager
         self.verbose = verbose
 
-        self.memory = ChatMemoryBuffer.from_defaults(token_limit=128000)
+        if chat_history:
+            msg_history = []
+            for inx, text in enumerate(chat_history):
+                role = MessageRole.USER if inx % 2 == 0 else MessageRole.ASSISTANT
+                msg_history.append(ChatMessage.from_str(content=text, role=role))
+            self.memory = ChatMemoryBuffer.from_defaults(token_limit=128000, chat_history=msg_history)
+        else:
+            self.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(
@@ -219,7 +277,10 @@ class Agent:
 
         # Compare tools
         if self.tools != other.tools:
-            print(f"Comparison failed: tools differ. (self.tools: {self.tools}, other.tools: {other.tools})")
+            print(
+                "Comparison failed: tools differ."
+                f"(self.tools: {[t.metadata.name for t in self.tools]}, "
+                f"other.tools: {[t.metadata.name for t in other.tools]})")
             return False
 
         # Compare topic
@@ -263,6 +324,7 @@ class Agent:
         agent_progress_callback: Optional[Callable[[AgentStatusType, str], None]] = None,
         query_logging_callback: Optional[Callable[[str, str], None]] = None,
         agent_config: AgentConfig = AgentConfig(),
+        chat_history: Optional[list[Tuple[str, str]]] = None,
     ) -> "Agent":
         """
         Create an agent from tools, agent type, and language model.
@@ -277,6 +339,7 @@ class Agent:
                 update_func (Callable): old name for agent_progress_callback. Will be deprecated in future.
             query_logging_callback (Callable): A callback function the code calls upon completion of a query
             agent_config (AgentConfig, optional): The configuration of the agent.
+            chat_history (Tuple[str, str], optional): A list of user/agent chat pairs to initialize the agent memory.
 
         Returns:
             Agent: An instance of the Agent class.
@@ -285,7 +348,8 @@ class Agent:
             tools=tools, topic=topic, custom_instructions=custom_instructions,
             verbose=verbose, agent_progress_callback=agent_progress_callback,
             query_logging_callback=query_logging_callback,
-            update_func=update_func, agent_config=agent_config
+            update_func=update_func, agent_config=agent_config,
+            chat_history=chat_history,
         )
 
     @classmethod
@@ -322,7 +386,7 @@ class Agent:
         vectara_temperature: Optional[float] = None,
         vectara_frequency_penalty: Optional[float] = None,
         vectara_presence_penalty: Optional[float] = None,
-        vectara_save_history: bool = False,
+        vectara_save_history: bool = True,
     ) -> "Agent":
         """
         Create an agent from a single Vectara corpus
@@ -383,6 +447,10 @@ class Agent:
             )  # type: ignore
         query_args = create_model("QueryArgs", **field_definitions)  # type: ignore
 
+        # tool name must be valid Python function name
+        if tool_name:
+            tool_name = re.sub(r"[^A-Za-z0-9_]", "_", tool_name)
+
         vectara_tool = vec_factory.create_rag_tool(
             tool_name=tool_name or f"vectara_{vectara_corpus_key}",
             tool_description=f"""
@@ -414,6 +482,7 @@ class Agent:
             presence_penalty=vectara_presence_penalty,
             save_history=vectara_save_history,
             include_citations=True,
+            verbose=verbose,
         )
 
         assistant_instructions = f"""
@@ -583,12 +652,13 @@ class Agent:
 
         for tool in self.tools:
             # Serialize each tool's metadata, function, and dynamic model schema (QueryArgs)
+            # TODO: deal with tools that have weakref (e.g. db_tools); for now those cannot be serialized.
             tool_dict = {
                 "tool_type": tool.metadata.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")
+                "fn": pickle.dumps(tool.fn).decode("latin-1") if tool.fn else None,  # Serialize fn
+                "async_fn": pickle.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()
@@ -599,7 +669,7 @@ class Agent:
 
         return {
             "agent_type": self.agent_type.value,
-            "memory": dill.dumps(self.agent.memory).decode("latin-1"),
+            "memory": pickle.dumps(self.agent.memory).decode("latin-1"),
             "tools": tool_info,
             "topic": self._topic,
             "custom_instructions": self._custom_instructions,
@@ -613,39 +683,30 @@ class Agent:
         agent_config = AgentConfig.from_dict(data["agent_config"])
         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():
+                    # Instead of checking for 'type', use the helper:
+                    field_type = get_field_type(values)
+                    # If there's a default value, include it.
                     if "default" in values:
                         field_definitions[field] = (
-                            json_type_to_python.get(values["type"], values["type"]),
-                            Field(
-                                description=values["description"],
-                                default=values["default"],
-                            ),
-                        )  # type: ignore
+                            field_type,
+                            Field(description=values.get("description", ""), default=values["default"]),
+                        )
                     else:
                         field_definitions[field] = (
-                            json_type_to_python.get(values["type"], values["type"]),
-                            Field(description=values["description"]),
-                        )  # type: ignore
+                            field_type,
+                            Field(description=values.get("description", "")),
+                        )
                 query_args_model = create_model("QueryArgs", **field_definitions)  # type: ignore
             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
+            fn = pickle.loads(tool_data["fn"].encode("latin-1")) if tool_data["fn"] else None
+            async_fn = pickle.loads(tool_data["async_fn"].encode("latin-1")) if tool_data["async_fn"] else None
 
             tool = VectaraTool.from_defaults(
                 name=tool_data["name"],
@@ -664,7 +725,7 @@ class Agent:
             custom_instructions=data["custom_instructions"],
             verbose=data["verbose"],
         )
-        memory = dill.loads(data["memory"].encode("latin-1")) if data.get("memory") else None
+        memory = pickle.loads(data["memory"].encode("latin-1")) if data.get("memory") else None
         if memory:
             agent.agent.memory = memory
         return agent

vectara_agentic/agent_config.py

@@ -44,6 +44,15 @@ class AgentConfig:
         default_factory=lambda: os.getenv("VECTARA_AGENTIC_TOOL_MODEL_NAME", "")
     )
 
+    # Params for Private LLM endpoint if used
+    private_llm_api_base: str = field(
+        default_factory=lambda: os.getenv("VECTARA_AGENTIC_PRIVATE_LLM_API_BASE",
+                                          "http://private-endpoint.company.com:5000/v1")
+    )
+    private_llm_api_key: str = field(
+        default_factory=lambda: os.getenv("VECTARA_AGENTIC_PRIVATE_LLM_API_KEY", "<private-api-key>")
+    )
+
     # Observer
     observer: ObserverType = field(
         default_factory=lambda: ObserverType(

vectara_agentic/tools.py

@@ -110,6 +110,9 @@ class VectaraTool(FunctionTool):
         if self.metadata.tool_type != other.metadata.tool_type:
             return False
 
+        if self.metadata.name != other.metadata.name or self.metadata.description != other.metadata.description:
+            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
@@ -252,7 +255,10 @@ def _build_filter_string(kwargs: Dict[str, Any], tool_args_type: Dict[str, dict]
                     filter_parts.append(f"{prefix}.{key}='{val_str}'")
 
     filter_str = " AND ".join(filter_parts)
-    return f"({fixed_filter}) AND ({filter_str})" if fixed_filter else filter_str
+    if fixed_filter and filter_str:
+        return f"({fixed_filter}) AND ({filter_str})"
+    else:
+        return fixed_filter or filter_str
 
 class VectaraToolFactory:
     """
@@ -294,7 +300,7 @@ class VectaraToolFactory:
         mmr_diversity_bias: float = 0.2,
         udf_expression: str = None,
         rerank_chain: List[Dict] = None,
-        save_history: bool = False,
+        save_history: bool = True,
         verbose: bool = False,
     ) -> VectaraTool:
         """
@@ -426,7 +432,7 @@ class VectaraToolFactory:
 
         # Create the tool function signature string
         fields = []
-        for name, field in tool_args_schema.__fields__.items():
+        for name, field in tool_args_schema.model_fields.items():
             annotation = field.annotation
             type_name = annotation.__name__ if hasattr(annotation, '__name__') else str(annotation)
             fields.append(f"{name}: {type_name}")
@@ -677,7 +683,7 @@ class VectaraToolFactory:
 
         # Create the tool function signature string
         fields = []
-        for name, field in tool_args_schema.__fields__.items():
+        for name, field in tool_args_schema.model_fields.items():
             annotation = field.annotation
             type_name = annotation.__name__ if hasattr(annotation, '__name__') else str(annotation)
             fields.append(f"{name}: {type_name}")

vectara_agentic/tools_catalog.py

@@ -25,7 +25,7 @@ get_headers = {
 
 def get_current_date() -> str:
     """
-    Returns: the current date.
+    Returns: the current date (when called) as a string.
     """
     return date.today().strftime("%A, %B %d, %Y")
 

vectara_agentic/types.py

@@ -33,6 +33,7 @@ class ModelProvider(Enum):
     COHERE = "COHERE"
     GEMINI = "GEMINI"
     BEDROCK = "BEDROCK"
+    PRIVATE = "PRIVATE"
 
 
 class AgentStatusType(Enum):

vectara_agentic/utils.py

@@ -112,6 +112,10 @@ def get_llm(
     elif model_provider == ModelProvider.COHERE:
         from llama_index.llms.cohere import Cohere
         llm = Cohere(model=model_name, temperature=0)
+    elif model_provider == ModelProvider.PRIVATE:
+        from llama_index.llms.openai_like import OpenAILike
+        llm = OpenAILike(model=model_name, temperature=0, is_function_calling_model=True,is_chat_model=True,
+                         api_base=config.private_llm_api_base, api_key=config.private_llm_api_key)
     else:
         raise ValueError(f"Unknown LLM provider: {model_provider}")
     return llm

{vectara_agentic-0.2.0.dist-info → vectara_agentic-0.2.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: vectara_agentic
-Version: 0.2.0
+Version: 0.2.1
 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
@@ -51,7 +51,7 @@ Requires-Dist: pydantic==2.10.3
 Requires-Dist: retrying==1.3.4
 Requires-Dist: python-dotenv==1.0.1
 Requires-Dist: tiktoken==0.8.0
-Requires-Dist: dill>=0.3.7
+Requires-Dist: cloudpickle>=3.1.1
 Requires-Dist: httpx==0.27.2
 Dynamic: author
 Dynamic: author-email
@@ -135,7 +135,7 @@ from vectara_agentic.tools import VectaraToolFactory
 vec_factory = VectaraToolFactory(
     vectara_api_key=os.environ['VECTARA_API_KEY'],
     vectara_customer_id=os.environ['VECTARA_CUSTOMER_ID'],
-    vectara_corpus_id=os.environ['VECTARA_CORPUS_ID']
+    vectara_corpus_key=os.environ['VECTARA_CORPUS_KEY']
 )
 ```
 
@@ -315,6 +315,10 @@ def mult_func(x, y):
 mult_tool = ToolsFactory().create_tool(mult_func)
 ```
 
+Note: When you define your own Python functions as tools, implement them at the top module level,
+and not as nested functions. Nested functions are not supported if you use serialization 
+(dumps/loads or from_dict/to_dict).
+
 ## 🛠️ Configuration
 
 ## Configuring Vectara-agentic
@@ -352,10 +356,31 @@ If any of these are not provided, `AgentConfig` first tries to read the values f
 
 When creating a `VectaraToolFactory`, you can pass in a `vectara_api_key`, `vectara_customer_id`, and `vectara_corpus_id` to the factory. 
 
-If not passed in, it will be taken from the environment variables (`VECTARA_API_KEY`, `VECTARA_CUSTOMER_ID` and `VECTARA_CORPUS_ID`). Note that `VECTARA_CORPUS_ID` can be a single ID or a comma-separated list of IDs (if you want to query multiple corpora).
+If not passed in, it will be taken from the environment variables (`VECTARA_API_KEY` and `VECTARA_CORPUS_KEY`). Note that `VECTARA_CORPUS_KEY` can be a single KEY or a comma-separated list of KEYs (if you want to query multiple corpora).
 
 These values will be used as credentials when creating Vectara tools - in `create_rag_tool()` and `create_search_tool()`.
 
+## Setting up a privately hosted LLM
+
+If you want to setup vectara-agentic to use your own self-hosted LLM endpoint, follow the example below
+
+```python
+        config = AgentConfig(
+            agent_type=AgentType.REACT,
+            main_llm_provider=ModelProvider.PRIVATE,
+            main_llm_model_name="meta-llama/Meta-Llama-3.1-8B-Instruct",
+            private_llm_api_base="http://vllm-server.company.com/v1",
+            private_llm_api_key="TEST_API_KEY",
+        )
+        agent = Agent(agent_config=config, tools=tools, topic=topic,
+                      custom_instructions=custom_instructions)
+```
+
+In this case we specify the Main LLM provider to be privately hosted with Llama-3.1-8B as the model.
+- The `ModelProvider.PRIVATE` specifies a privately hosted LLM.
+- The `private_llm_api_base` specifies the api endpoint to use, and the `private_llm_api_key`
+  specifies the private API key requires to use this service.
+
 ## ℹ️ Additional Information
 
 ### About Custom Instructions for your Agent
@@ -376,6 +401,8 @@ The `Agent` class defines a few helpful methods to help you understand the inter
 
 The `Agent` class supports serialization. Use the `dumps()` to serialize and `loads()` to read back from a serialized stream.
 
+Note: due to cloudpickle limitations, if a tool contains Python `weakref` objects, serialization won't work and an exception will be raised.
+
 ###  Observability
 
 vectara-agentic supports observability via the existing integration of LlamaIndex and Arize Phoenix.

vectara_agentic-0.2.1.dist-info/RECORD

@@ -0,0 +1,23 @@
+tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/endpoint.py,sha256=rnHyXEZhjipyR2Stj2Mum331REChWuhmn5WPpyDryV0,1291
+tests/test_agent.py,sha256=SzSE1T_9PyIs-LUjj-fJjfGDlpJBzHUigyVX-KEhmJ4,4967
+tests/test_private_llm.py,sha256=b7RrOHHsTQKARHskCbh2I4f_LmjZmD5bdk1oEWGhP7s,2150
+tests/test_tools.py,sha256=lPihJ5mRdK66exWqDFRPEYIM2kUDeGtoaiG78UH5WMs,3499
+vectara_agentic/__init__.py,sha256=ADH4fPKLbpGNYYYszv3c3QDOjPToPE_qh3LpkH_seCU,430
+vectara_agentic/_callback.py,sha256=jpzHqnl297k2qajYc-6nkPtIPtgVLpVWYEISHS7ySlM,9186
+vectara_agentic/_observability.py,sha256=HeQYJIkqPLW3EWHiXHatkaJzo08IQGESKujdeWTuRgk,3805
+vectara_agentic/_prompts.py,sha256=7xOcRf9XNtpfFpDIUzgb-yMQ516K8X7bAzayAp406FU,6595
+vectara_agentic/_version.py,sha256=r1kR7ilT4Tx4v5m7GtBI1hwUMe-C5VRwnozb3l382_0,65
+vectara_agentic/agent.py,sha256=LMnJJfw2udDrsZAVlYpji0_rkmasHOsCuv206UJpH7Q,32007
+vectara_agentic/agent_config.py,sha256=yof3zU8OgYE5441EAwcoDBpTHDM5lNN-CyeO0LrT4-c,3350
+vectara_agentic/agent_endpoint.py,sha256=QIMejCLlpW2qzXxeDAxv3anF46XMDdVMdKGWhJh3azY,1996
+vectara_agentic/db_tools.py,sha256=3_hPrutNIGEeU2kH503GjcYbtAMsK6BidQLIm6DT6C8,3591
+vectara_agentic/tools.py,sha256=gI6zsVNh2SfAOqeQ5ZzAmf8NxkmtV6NUPJsTN7Cnb7o,39440
+vectara_agentic/tools_catalog.py,sha256=0gfF-JzTEnFS8e_x2uA6mvcvjVkY9ygRskxJetKGtrs,5231
+vectara_agentic/types.py,sha256=Qy7c7gSXJbvzddzhSRx2Flaf6a3go8u2LW17IKNxkKI,1603
+vectara_agentic/utils.py,sha256=ZhS82hA9yconr9yqDJ0GCBUjRxc06ZTlFaBzF67Yb3Y,5008
+vectara_agentic-0.2.1.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+vectara_agentic-0.2.1.dist-info/METADATA,sha256=ZZpRSVHVy9gI9QsNHFKKtdYyl3DWbR_h_LyD6oX9bJw,21857
+vectara_agentic-0.2.1.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+vectara_agentic-0.2.1.dist-info/top_level.txt,sha256=Y7TQTFdOYGYodQRltUGRieZKIYuzeZj2kHqAUpfCUfg,22
+vectara_agentic-0.2.1.dist-info/RECORD,,

vectara_agentic-0.2.0.dist-info/RECORD

@@ -1,21 +0,0 @@
-tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/test_agent.py,sha256=bhKwmWsYTwTCrI-D4hXGKZPPDzgOJF3XtjhYo-bV2xc,3963
-tests/test_tools.py,sha256=Nn8iTabsCspABdt3eW13lAy8GJL1xRS42XQxBhwN__I,2762
-vectara_agentic/__init__.py,sha256=ADH4fPKLbpGNYYYszv3c3QDOjPToPE_qh3LpkH_seCU,430
-vectara_agentic/_callback.py,sha256=jpzHqnl297k2qajYc-6nkPtIPtgVLpVWYEISHS7ySlM,9186
-vectara_agentic/_observability.py,sha256=HeQYJIkqPLW3EWHiXHatkaJzo08IQGESKujdeWTuRgk,3805
-vectara_agentic/_prompts.py,sha256=mgGx3zUJPtpS1epBLtl0BnoLeE7wb6AX1SX6dFNaTTQ,6368
-vectara_agentic/_version.py,sha256=BLvF264tVnfoZW3j2NXD3gU6WcA1j4dfS2TtMqZ6oJs,65
-vectara_agentic/agent.py,sha256=57VftipZRZXAwf6LXdyY0zsyCInLcR0ZGvYr1SwTakI,29354
-vectara_agentic/agent_config.py,sha256=9P9lyFAAXLX1ft2dBQ6tYN7dKzp7SC7B-h-DnhUHsSg,2941
-vectara_agentic/agent_endpoint.py,sha256=QIMejCLlpW2qzXxeDAxv3anF46XMDdVMdKGWhJh3azY,1996
-vectara_agentic/db_tools.py,sha256=3_hPrutNIGEeU2kH503GjcYbtAMsK6BidQLIm6DT6C8,3591
-vectara_agentic/tools.py,sha256=xhi8lvs351_8WQPQu6oOMdwond9MqqqVt9RHR4NjazI,39238
-vectara_agentic/tools_catalog.py,sha256=O3vYFpZ5EQeh37X70TiHepXFGN5yGk4_d7CkrkLeUhk,5205
-vectara_agentic/types.py,sha256=8yeRHr1iYV9lmsWUwtfreHUvYaw1u9CSiQIhBkjcWxc,1579
-vectara_agentic/utils.py,sha256=eDEOUpCkb0r216LxSLkamll2NmJhu76Z1TgQFbAVq7A,4690
-vectara_agentic-0.2.0.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-vectara_agentic-0.2.0.dist-info/METADATA,sha256=iHGfo8TF7CfneXOKNTXdWoYDuiOILc77uru_HzPX1H0,20564
-vectara_agentic-0.2.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-vectara_agentic-0.2.0.dist-info/top_level.txt,sha256=Y7TQTFdOYGYodQRltUGRieZKIYuzeZj2kHqAUpfCUfg,22
-vectara_agentic-0.2.0.dist-info/RECORD,,