vectara-agentic 0.1.28__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

@@ -1,9 +1,10 @@
 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
 from vectara_agentic.agent_config import AgentConfig
 from vectara_agentic.types import ModelProvider, ObserverType
+from vectara_agentic.tools import ToolsFactory
 
 class TestAgentPackage(unittest.TestCase):
     def test_get_prompt(self):
@@ -23,16 +24,11 @@ class TestAgentPackage(unittest.TestCase):
         def mult(x, y):
             return x * y
 
-        tools = [
-            FunctionTool.from_defaults(
-                fn=mult, name="mult", description="Multiplication functions"
-            )
-        ]
+        tools = [ToolsFactory().create_tool(mult)]
         topic = "AI"
         custom_instructions = "Always do as your mother tells you!"
         agent = Agent(tools, topic, custom_instructions)
         self.assertEqual(agent.agent_type, AgentType.OPENAI)
-        self.assertEqual(agent.tools, tools)
         self.assertEqual(agent._topic, topic)
         self.assertEqual(agent._custom_instructions, custom_instructions)
 
@@ -40,7 +36,7 @@ class TestAgentPackage(unittest.TestCase):
         self.assertEqual(
             agent.chat(
                 "What is 5 times 10. Only give the answer, nothing else"
-            ).replace("$", "\\$"),
+            ).response.replace("$", "\\$"),
             "50",
         )
 
@@ -48,11 +44,7 @@ class TestAgentPackage(unittest.TestCase):
         def mult(x, y):
             return x * y
 
-        tools = [
-            FunctionTool.from_defaults(
-                fn=mult, name="mult", description="Multiplication functions"
-            )
-        ]
+        tools = [ToolsFactory().create_tool(mult)]
         topic = "AI topic"
         instructions = "Always do as your father tells you, if your mother agrees!"
         config = AgentConfig(
@@ -70,7 +62,6 @@ class TestAgentPackage(unittest.TestCase):
             custom_instructions=instructions,
             agent_config=config
         )
-        self.assertEqual(agent.tools, tools)
         self.assertEqual(agent._topic, topic)
         self.assertEqual(agent._custom_instructions, instructions)
         self.assertEqual(agent.agent_type, AgentType.REACT)
@@ -78,19 +69,36 @@ class TestAgentPackage(unittest.TestCase):
         self.assertEqual(agent.agent_config.main_llm_provider, ModelProvider.ANTHROPIC)
         self.assertEqual(agent.agent_config.tool_llm_provider, ModelProvider.TOGETHER)
 
-        # To run this test, you must have OPENAI_API_KEY in your environment
+        # To run this test, you must have ANTHROPIC_API_KEY and TOGETHER_API_KEY in your environment
         self.assertEqual(
             agent.chat(
                 "What is 5 times 10. Only give the answer, nothing else"
-            ).replace("$", "\\$"),
+            ).response.replace("$", "\\$"),
             "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",
-            vectara_customer_id="4584783",
-            vectara_corpus_id="4",
+            vectara_corpus_key="corpus_key",
             vectara_api_key="api_key",
             data_description="information",
             assistant_specialty="question answering",
@@ -102,16 +110,22 @@ class TestAgentPackage(unittest.TestCase):
     def test_serialization(self):
         agent = Agent.from_corpus(
             tool_name="RAG Tool",
-            vectara_customer_id="4584783",
-            vectara_corpus_id="4",
+            vectara_corpus_key="corpus_key",
             vectara_api_key="api_key",
             data_description="information",
             assistant_specialty="question answering",
         )
 
         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,22 +1,23 @@
 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
 
 
 class TestToolsPackage(unittest.TestCase):
     def test_vectara_tool_factory(self):
-        vectara_customer_id = "4584783"
-        vectara_corpus_id = "4"
+        vectara_corpus_key = "corpus_key"
         vectara_api_key = "api_key"
         vec_factory = VectaraToolFactory(
-            vectara_customer_id, vectara_corpus_id, vectara_api_key
+            vectara_corpus_key, vectara_api_key
         )
 
-        self.assertEqual(vectara_customer_id, vec_factory.vectara_customer_id)
-        self.assertEqual(vectara_corpus_id, vec_factory.vectara_corpus_id)
+        self.assertEqual(vectara_corpus_key, vec_factory.vectara_corpus_key)
         self.assertEqual(vectara_api_key, vec_factory.vectara_api_key)
 
         class QueryToolArgs(BaseModel):
@@ -59,16 +60,11 @@ class TestToolsPackage(unittest.TestCase):
         self.assertEqual(arxiv_tool.metadata.tool_type, ToolType.QUERY)
 
     def test_public_repo(self):
-        vectara_customer_id = "1366999410"
-        vectara_corpus_id = "1"
+        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_customer_id=vectara_customer_id,
-            vectara_corpus_id=vectara_corpus_id,
+            vectara_corpus_key=vectara_corpus_key,
             vectara_api_key=vectara_api_key,
             tool_name="ask_vectara",
             data_description="data from Vectara website",
@@ -76,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/_callback.py

@@ -146,7 +146,8 @@ class AgentCallbackHandler(BaseCallbackHandler):
         if EventPayload.MESSAGES in payload:
             response = str(payload.get(EventPayload.RESPONSE))
             if response and response not in ["None", "assistant: None"]:
-                self.fn(AgentStatusType.AGENT_UPDATE, response)
+                if self.fn:
+                    self.fn(AgentStatusType.AGENT_UPDATE, response)
         else:
             print(f"No messages or prompt found in payload {payload}")
 
@@ -156,23 +157,27 @@ class AgentCallbackHandler(BaseCallbackHandler):
             tool = payload.get(EventPayload.TOOL)
             if tool:
                 tool_name = tool.name
-                self.fn(
-                    AgentStatusType.TOOL_CALL,
-                    f"Executing '{tool_name}' with arguments: {fcall}",
-                )
+                if self.fn:
+                    self.fn(
+                        AgentStatusType.TOOL_CALL,
+                        f"Executing '{tool_name}' with arguments: {fcall}",
+                    )
         elif EventPayload.FUNCTION_OUTPUT in payload:
             response = str(payload.get(EventPayload.FUNCTION_OUTPUT))
-            self.fn(AgentStatusType.TOOL_OUTPUT, response)
+            if self.fn:
+                self.fn(AgentStatusType.TOOL_OUTPUT, response)
         else:
             print(f"No function call or output found in payload {payload}")
 
     def _handle_agent_step(self, payload: dict) -> None:
         if EventPayload.MESSAGES in payload:
             msg = str(payload.get(EventPayload.MESSAGES))
-            self.fn(AgentStatusType.AGENT_STEP, msg)
+            if self.fn:
+                self.fn(AgentStatusType.AGENT_STEP, msg)
         elif EventPayload.RESPONSE in payload:
             response = str(payload.get(EventPayload.RESPONSE))
-            self.fn(AgentStatusType.AGENT_STEP, response)
+            if self.fn:
+                self.fn(AgentStatusType.AGENT_STEP, response)
         else:
             print(f"No messages or prompt found in payload {payload}")
 
@@ -181,10 +186,11 @@ class AgentCallbackHandler(BaseCallbackHandler):
         if EventPayload.MESSAGES in payload:
             response = str(payload.get(EventPayload.RESPONSE))
             if response and response not in ["None", "assistant: None"]:
-                if inspect.iscoroutinefunction(self.fn):
-                    await self.fn(AgentStatusType.AGENT_UPDATE, response)
-                else:
-                    self.fn(AgentStatusType.AGENT_UPDATE, response)
+                if self.fn:
+                    if inspect.iscoroutinefunction(self.fn):
+                        await self.fn(AgentStatusType.AGENT_UPDATE, response)
+                    else:
+                        self.fn(AgentStatusType.AGENT_UPDATE, response)
         else:
             print(f"No messages or prompt found in payload {payload}")
 
@@ -194,37 +200,41 @@ class AgentCallbackHandler(BaseCallbackHandler):
             tool = payload.get(EventPayload.TOOL)
             if tool:
                 tool_name = tool.name
+                if self.fn:
+                    if inspect.iscoroutinefunction(self.fn):
+                        await self.fn(
+                            AgentStatusType.TOOL_CALL,
+                            f"Executing '{tool_name}' with arguments: {fcall}",
+                        )
+                    else:
+                        self.fn(
+                            AgentStatusType.TOOL_CALL,
+                            f"Executing '{tool_name}' with arguments: {fcall}",
+                        )
+        elif EventPayload.FUNCTION_OUTPUT in payload:
+            if self.fn:
+                response = str(payload.get(EventPayload.FUNCTION_OUTPUT))
                 if inspect.iscoroutinefunction(self.fn):
-                    await self.fn(
-                        AgentStatusType.TOOL_CALL,
-                        f"Executing '{tool_name}' with arguments: {fcall}",
-                    )
+                    await self.fn(AgentStatusType.TOOL_OUTPUT, response)
                 else:
-                    self.fn(
-                        AgentStatusType.TOOL_CALL,
-                        f"Executing '{tool_name}' with arguments: {fcall}",
-                    )
-        elif EventPayload.FUNCTION_OUTPUT in payload:
-            response = str(payload.get(EventPayload.FUNCTION_OUTPUT))
-            if inspect.iscoroutinefunction(self.fn):
-                await self.fn(AgentStatusType.TOOL_OUTPUT, response)
-            else:
-                self.fn(AgentStatusType.TOOL_OUTPUT, response)
+                    self.fn(AgentStatusType.TOOL_OUTPUT, response)
         else:
             print(f"No function call or output found in payload {payload}")
 
     async def _ahandle_agent_step(self, payload: dict) -> None:
         if EventPayload.MESSAGES in payload:
-            msg = str(payload.get(EventPayload.MESSAGES))
-            if inspect.iscoroutinefunction(self.fn):
-                await self.fn(AgentStatusType.AGENT_STEP, msg)
-            else:
-                self.fn(AgentStatusType.AGENT_STEP, msg)
+            if self.fn:
+                msg = str(payload.get(EventPayload.MESSAGES))
+                if inspect.iscoroutinefunction(self.fn):
+                    await self.fn(AgentStatusType.AGENT_STEP, msg)
+                else:
+                    self.fn(AgentStatusType.AGENT_STEP, msg)
         elif EventPayload.RESPONSE in payload:
-            response = str(payload.get(EventPayload.RESPONSE))
-            if inspect.iscoroutinefunction(self.fn):
-                await self.fn(AgentStatusType.AGENT_STEP, response)
-            else:
-                self.fn(AgentStatusType.AGENT_STEP, response)
+            if self.fn:
+                response = str(payload.get(EventPayload.RESPONSE))
+                if inspect.iscoroutinefunction(self.fn):
+                    await self.fn(AgentStatusType.AGENT_STEP, response)
+                else:
+                    self.fn(AgentStatusType.AGENT_STEP, response)
         else:
             print(f"No messages or prompt found in payload {payload}")

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.1.28"
+__version__ = "0.2.1"