vectara-agentic 0.2.22__tar.gz → 0.2.24__tar.gz

{vectara_agentic-0.2.22/vectara_agentic.egg-info → vectara_agentic-0.2.24}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vectara_agentic
-Version: 0.2.22
+Version: 0.2.24
 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
@@ -530,6 +530,9 @@ class MyWorkflow(Workflow):
     class OutputsModel(BaseModel):
         answer: str
 
+    class OutputModelOnFail(BaseModel):
+        partial_response: str = ""
+
     @step
     async def my_step(self, ev: StartEvent) -> StopEvent:
         # do something here
@@ -587,6 +590,11 @@ workflow_result = asyncio.run(agent.run(inputs))
 print(workflow_result.answer)
 ```
 
+When a workflow reaches its timeout, the timeout handler builds and returns an `OutputModelOnFail` 
+by reading each field named in that model from the workflow’s Context; for any field that isn’t set in the context, 
+it uses the default value you’ve defined on `OutputModelOnFail`. In other words, every property in `OutputModelOnFail` 
+must declare a default so that even if the corresponding context variable is missing, the model can be fully populated and returned without errors.
+
 ### Built-in Workflows
 
 `vectara-agentic` includes two workflow implementations that you can use right away:

{vectara_agentic-0.2.22 → vectara_agentic-0.2.24}/README.md

@@ -454,6 +454,9 @@ class MyWorkflow(Workflow):
     class OutputsModel(BaseModel):
         answer: str
 
+    class OutputModelOnFail(BaseModel):
+        partial_response: str = ""
+
     @step
     async def my_step(self, ev: StartEvent) -> StopEvent:
         # do something here
@@ -511,6 +514,11 @@ workflow_result = asyncio.run(agent.run(inputs))
 print(workflow_result.answer)
 ```
 
+When a workflow reaches its timeout, the timeout handler builds and returns an `OutputModelOnFail` 
+by reading each field named in that model from the workflow’s Context; for any field that isn’t set in the context, 
+it uses the default value you’ve defined on `OutputModelOnFail`. In other words, every property in `OutputModelOnFail` 
+must declare a default so that even if the corresponding context variable is missing, the model can be fully populated and returned without errors.
+
 ### Built-in Workflows
 
 `vectara-agentic` includes two workflow implementations that you can use right away:

{vectara_agentic-0.2.22 → vectara_agentic-0.2.24}/tests/test_workflow.py

@@ -1,9 +1,5 @@
 import unittest
 
-from pydantic import BaseModel
-
-from llama_index.core.workflow import WorkflowTimeoutError
-
 from vectara_agentic.agent import Agent
 from vectara_agentic.agent_config import AgentConfig
 from vectara_agentic.tools import ToolsFactory
@@ -68,7 +64,7 @@ class TestWorkflowPackage(unittest.IsolatedAsyncioTestCase):
 
 class TestWorkflowFailure(unittest.IsolatedAsyncioTestCase):
 
-    async def test_workflow_failure(self):
+    async def test_workflow_failure_sub_question(self):
         tools = [ToolsFactory().create_tool(mult)] + [ToolsFactory().create_tool(add)]
         topic = "AI topic"
         instructions = "You are a helpful AI assistant."
@@ -84,50 +80,27 @@ class TestWorkflowFailure(unittest.IsolatedAsyncioTestCase):
         inputs = SubQuestionQueryWorkflow.InputsModel(
             query="Compute 5 times 3, then add 7 to the result."
         )
+        res = await agent.run(inputs=inputs)
+        self.assertIsInstance(res, SubQuestionQueryWorkflow.OutputModelOnFail)
 
-        res = None
-
-        try:
-            res = await agent.run(inputs=inputs)
-        except Exception as e:
-            self.assertIsInstance(e, WorkflowTimeoutError)
-
-        self.assertIsNone(res)
-
-    async def test_workflow_with_fail_class(self):
+    async def test_workflow_failure_seq_sub_question(self):
         tools = [ToolsFactory().create_tool(mult)] + [ToolsFactory().create_tool(add)]
         topic = "AI topic"
         instructions = "You are a helpful AI assistant."
-
-        class SubQuestionQueryWorkflowWithFailClass(SubQuestionQueryWorkflow):
-            class OutputModelOnFail(BaseModel):
-                """
-                In case of failure, returns the user's original query
-                """
-                original_query: str
-
         agent = Agent(
             tools=tools,
             topic=topic,
             custom_instructions=instructions,
             agent_config = AgentConfig(),
-            workflow_cls = SubQuestionQueryWorkflowWithFailClass,
+            workflow_cls = SequentialSubQuestionsWorkflow,
             workflow_timeout = 1
         )
 
-        inputs = SubQuestionQueryWorkflow.InputsModel(
+        inputs = SequentialSubQuestionsWorkflow.InputsModel(
             query="Compute 5 times 3, then add 7 to the result."
         )
-
-        res = None
-
-        try:
-            res = await agent.run(inputs=inputs)
-        except Exception as e:
-            assert isinstance(e, WorkflowTimeoutError)
-
-        self.assertIsInstance(res, SubQuestionQueryWorkflowWithFailClass.OutputModelOnFail)
-        self.assertEqual(res.original_query, "Compute 5 times 3, then add 7 to the result.")
+        res = await agent.run(inputs=inputs)
+        self.assertIsInstance(res, SequentialSubQuestionsWorkflow.OutputModelOnFail)
 
 
 if __name__ == "__main__":

{vectara_agentic-0.2.22 → vectara_agentic-0.2.24}/vectara_agentic/_prompts.py

@@ -44,6 +44,7 @@ GENERAL_INSTRUCTIONS = """
 - If you are provided with database tools use them for analytical queries (such as counting, calculating max, min, average, sum, or other statistics).
   For each database, the database tools include: x_list_tables, x_load_data, x_describe_tables, x_load_unique_values, and x_load_sample_data, where 'x' in the database name.
   for example, if the database name is "ev", the tools are: ev_list_tables, ev_load_data, ev_describe_tables, ev_load_unique_values, and ev_load_sample_data.
+  Use ANSI SQL-92 syntax for the SQL queries, and do not use any other SQL dialect.
   Before using the x_load_data with a SQL query, always follow these discovery steps:
   - call the x_list_tables tool to list of available tables in the x database.
   - Call the x_describe_tables tool to understand the schema of each table you want to query data from.

{vectara_agentic-0.2.22 → vectara_agentic-0.2.24}/vectara_agentic/_version.py

@@ -1,4 +1,4 @@
 """
 Define the version of the package.
 """
-__version__ = "0.2.22"
+__version__ = "0.2.24"

{vectara_agentic-0.2.22 → vectara_agentic-0.2.24}/vectara_agentic/agent.py

@@ -15,6 +15,8 @@ from collections import Counter
 import inspect
 from inspect import Signature, Parameter, ismethod
 from pydantic import Field, create_model, ValidationError, BaseModel
+from pydantic_core import PydanticUndefined
+
 import cloudpickle as pickle
 
 from dotenv import load_dotenv
@@ -1083,6 +1085,15 @@ class Agent:
         if not isinstance(inputs, self.workflow_cls.InputsModel):
             raise ValueError(f"Inputs must be an instance of {workflow.InputsModel}.")
 
+        outputs_model_on_fail_cls = getattr(workflow.__class__, "OutputModelOnFail", None)
+        if outputs_model_on_fail_cls:
+            fields_without_default = []
+            for name, field_info in outputs_model_on_fail_cls.model_fields.items():
+                if field_info.default_factory is PydanticUndefined:
+                    fields_without_default.append(name)
+            if fields_without_default:
+                raise ValueError(f"Fields without default values: {fields_without_default}")
+
         workflow_context = Context(workflow=workflow)
         try:
             # run workflow
@@ -1102,15 +1113,14 @@ class Agent:
                 raise ValueError(f"Failed to map workflow output to model: {e}") from e
 
         except Exception as e:
-            outputs_model_on_fail_cls = getattr(workflow.__class__, "OutputModelOnFail", None)
+            _missing = object()
             if outputs_model_on_fail_cls:
                 model_fields = outputs_model_on_fail_cls.model_fields
-                input_dict = {
-                    key: await workflow_context.get(key, None)
-                    for key in model_fields
-                }
-
-                # return output in the form of workflow.OutputModelOnFail(BaseModel)
+                input_dict = {}
+                for key in model_fields:
+                    value = await workflow_context.get(key, default=_missing)
+                    if value is not _missing:
+                        input_dict[key] = value
                 output = outputs_model_on_fail_cls.model_validate(input_dict)
             else:
                 print(f"Vectara Agentic: Workflow failed with unexpected error: {e}")

{vectara_agentic-0.2.22 → vectara_agentic-0.2.24}/vectara_agentic/db_tools.py

@@ -114,7 +114,7 @@ class DatabaseTools:
         if sql_query is None:
             raise ValueError("A query parameter is necessary to filter the data.")
 
-        count_query = f"SELECT COUNT(*) FROM ({sql_query})"
+        count_query = f"SELECT COUNT(*) FROM ({sql_query}) c"
         try:
             count_rows = self._load_data(count_query)
         except Exception as e:

{vectara_agentic-0.2.22 → vectara_agentic-0.2.24}/vectara_agentic/sub_query_workflow.py

@@ -5,7 +5,7 @@ that takes a user question and a list of tools, and outputs a list of sub-questi
 
 import re
 import json
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 
 from llama_index.core.workflow import (
     step,
@@ -37,6 +37,13 @@ class SubQuestionQueryWorkflow(Workflow):
 
         response: str
 
+    class OutputModelOnFail(BaseModel):
+        """
+        Outputs for the workflow when it fails.
+        """
+
+        qna: list[tuple[str,str]] = Field(default_factory=list, description="List of question-answer pairs")
+
     # Workflow Event types
     class QueryEvent(Event):
         """Event for a query."""
@@ -141,7 +148,7 @@ class SubQuestionQueryWorkflow(Workflow):
 
         return None
 
-    @step(num_workers=4)
+    @step(num_workers=8)
     async def sub_question(self, ctx: Context, ev: QueryEvent) -> AnswerEvent:
         """
         Given a sub-question, return the answer to the sub-question, using the agent.
@@ -149,8 +156,11 @@ class SubQuestionQueryWorkflow(Workflow):
         if await ctx.get("verbose"):
             print(f"Sub-question is {ev.question}")
         agent = await ctx.get("agent")
-        response = await agent.achat(ev.question)
-        return self.AnswerEvent(question=ev.question, answer=str(response))
+        question = ev.question
+        response = await agent.achat(question)
+        answer = str(response)
+        await ctx.set("qna", await ctx.get("qna", []) + [(question, answer)])
+        return self.AnswerEvent(question=question, answer=answer)
 
     @step
     async def combine_answers(self, ctx: Context, ev: AnswerEvent) -> StopEvent | None:
@@ -209,6 +219,15 @@ class SequentialSubQuestionsWorkflow(Workflow):
 
         response: str
 
+    class OutputModelOnFail(BaseModel):
+        """
+        Outputs for the workflow when it fails.
+        """
+
+        qna: list[tuple[str,str]] = Field(
+            default_factory=list, description="List of question-answer pairs"
+        )
+
     # Workflow Event types
     class QueryEvent(Event):
         """Event for a query."""
@@ -322,24 +341,27 @@ class SequentialSubQuestionsWorkflow(Workflow):
             print(f"Sub-question is {ev.question}")
         agent = await ctx.get("agent")
         sub_questions = await ctx.get("sub_questions")
+        question = ev.question
         if ev.prev_answer:
             prev_question = sub_questions[ev.num - 1]
             prompt = f"""
                 The answer to the question '{prev_question}' is: '{ev.prev_answer}'
-                Now answer the following question: '{ev.question}'
+                Now answer the following question: '{question}'
             """
             response = await agent.achat(prompt)
         else:
-            response = await agent.achat(ev.question)
+            response = await agent.achat(question)
+        answer = response.response
         if await ctx.get("verbose"):
-            print(f"Answer is {response}")
+            print(f"Answer is {answer}")
 
         if ev.num + 1 < len(sub_questions):
+            await ctx.set("qna", await ctx.get("qna", []) + [(question, answer)])
             return self.QueryEvent(
                 question=sub_questions[ev.num + 1],
-                prev_answer=response.response,
+                prev_answer=answer,
                 num=ev.num + 1,
             )
 
-        output = self.OutputsModel(response=response.response)
+        output = self.OutputsModel(response=answer)
         return StopEvent(result=output)

{vectara_agentic-0.2.22 → vectara_agentic-0.2.24}/vectara_agentic/tools.py

@@ -129,6 +129,8 @@ class VectaraToolFactory:
                 - 'type': the type of each filter attribute in Vectara (doc or part).
                 - 'is_list': whether the filterable attribute is a list.
                 - 'filter_name': the name of the filterable attribute in Vectara.
+            summarize_docs (bool, optional): Whether to summarize the retrieved documents.
+            summarize_llm_name (str, optional): The name of the LLM to use for summarization.
             fixed_filter (str, optional): A fixed Vectara filter condition to apply to all queries.
             lambda_val (Union[List[float] | float], optional): Lambda value (or list of values for each corpora)
                 for the Vectara query, when using hybrid search.
@@ -234,10 +236,13 @@ class VectaraToolFactory:
                 )
             unique_ids = set()
             docs = []
+            doc_matches = {}
             for doc in response:
                 if doc.id_ in unique_ids:
+                    doc_matches[doc.id_].append(doc.node.get_content())
                     continue
                 unique_ids.add(doc.id_)
+                doc_matches[doc.id_] = [doc.node.get_content()]
                 docs.append((doc.id_, doc.metadata))
             tool_output = "Matching documents:\n"
             if summarize:
@@ -251,11 +256,24 @@ class VectaraToolFactory:
                 )
                 for doc_id, metadata in docs:
                     summary = summaries_dict.get(doc_id, "")
-                    tool_output += f"document_id: '{doc_id}'\nmetadata: '{metadata}'\nsummary: '{summary}'\n\n"
+                    matching_text = "\n".join(
+                        f"<match {i}>{piece}</match {i}>"
+                        for i, piece in enumerate(doc_matches[doc_id], start=1)
+                    )
+                    tool_output += (
+                        f"document_id: '{doc_id}'\nmetadata: '{metadata}'\n"
+                        f"matching texts: '{matching_text}'\n"
+                        f"summary: '{summary}'\n\n"
+                    )
             else:
                 for doc_id, metadata in docs:
+                    matching_text = "\n".join(
+                        f"<match {i}>{piece}</match {i}>"
+                        for i, piece in enumerate(doc_matches[doc_id], start=1)
+                    )
                     tool_output += (
-                        f"document_id: '{doc_id}'\nmetadata: '{metadata}'\n\n"
+                        f"document_id: '{doc_id}'\nmetadata: '{metadata}'\n"
+                        f"matching texts: '{matching_text}'\n"
                     )
 
             out = ToolOutput(

{vectara_agentic-0.2.22 → vectara_agentic-0.2.24/vectara_agentic.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vectara_agentic
-Version: 0.2.22
+Version: 0.2.24
 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
@@ -530,6 +530,9 @@ class MyWorkflow(Workflow):
     class OutputsModel(BaseModel):
         answer: str
 
+    class OutputModelOnFail(BaseModel):
+        partial_response: str = ""
+
     @step
     async def my_step(self, ev: StartEvent) -> StopEvent:
         # do something here
@@ -587,6 +590,11 @@ workflow_result = asyncio.run(agent.run(inputs))
 print(workflow_result.answer)
 ```
 
+When a workflow reaches its timeout, the timeout handler builds and returns an `OutputModelOnFail` 
+by reading each field named in that model from the workflow’s Context; for any field that isn’t set in the context, 
+it uses the default value you’ve defined on `OutputModelOnFail`. In other words, every property in `OutputModelOnFail` 
+must declare a default so that even if the corresponding context variable is missing, the model can be fully populated and returned without errors.
+
 ### Built-in Workflows
 
 `vectara-agentic` includes two workflow implementations that you can use right away: