vectara-agentic 0.2.4__py3-none-any.whl → 0.2.6__py3-none-any.whl

vectara_agentic/db_tools.py

@@ -13,7 +13,7 @@ class DBTool(ABC):
     """
     A base class for vectara-agentic database tools extensions
     """
-    def __init__(self, load_data_fn: Callable, max_rows: int = 500):
+    def __init__(self, load_data_fn: Callable, max_rows: int = 1000):
         self.load_data_fn = load_data_fn
         self.max_rows = max_rows
 
@@ -39,7 +39,7 @@ class DBLoadData(DBTool):
         if num_rows > self.max_rows:
             return [
                 f"The query is expected to return more than {self.max_rows} rows. "
-                "Please refine your query to make it return less rows."
+                "Please refactor your query to make it return less rows. "
             ]
         try:
             res = self.load_data_fn(query)

vectara_agentic/sub_query_workflow.py

@@ -0,0 +1,292 @@
+"""
+This module contains the SubQuestionQueryEngine workflow, which is a workflow
+that takes a user question and a list of tools, and outputs a list of sub-questions.
+"""
+import json
+from pydantic import BaseModel
+
+from llama_index.core.workflow import (
+    step,
+    Context,
+    Workflow,
+    Event,
+    StartEvent,
+    StopEvent,
+)
+
+class SubQuestionQueryWorkflow(Workflow):
+    """
+    Workflow for sub-question query engine.
+    """
+
+    # Workflow inputs/outputs
+    class InputsModel(BaseModel):
+        """
+        Inputs for the workflow.
+        """
+        query: str
+
+    class OutputsModel(BaseModel):
+        """
+        Outputs for the workflow.
+        """
+        response: str
+
+    # Workflow Event types
+    class QueryEvent(Event):
+        """Event for a query."""
+        question: str
+
+    class AnswerEvent(Event):
+        """Event for an answer."""
+        question: str
+        answer: str
+
+    @step
+    async def query(self, ctx: Context, ev: StartEvent) -> QueryEvent:
+        """
+        Given a user question, and a list of tools, output a list of relevant
+        sub-questions, such that the answers to all the sub-questions put together
+        will answer the question.
+        """
+        if not hasattr(ev, "inputs"):
+            raise ValueError("No inputs provided to workflow Start Event.")
+        if hasattr(ev, "inputs") and not isinstance(ev.inputs, self.InputsModel):
+            raise ValueError(f"Expected inputs to be of type {self.InputsModel}")
+        if hasattr(ev, "inputs"):
+            query = ev.inputs.query
+            await ctx.set("original_query", query)
+            print(f"Query is {await ctx.get('original_query')}")
+
+        if hasattr(ev, "agent"):
+            await ctx.set("agent", ev.agent)
+        else:
+            raise ValueError("Agent not provided to workflow Start Event.")
+        chat_history = [str(msg) for msg in ev.agent.memory.get()]
+
+        if hasattr(ev, "llm"):
+            await ctx.set("llm", ev.llm)
+        else:
+            raise ValueError("LLM not provided to workflow Start Event.")
+
+        if hasattr(ev, "tools"):
+            await ctx.set("tools", ev.tools)
+        else:
+            raise ValueError("Tools not provided to workflow Start Event.")
+
+        if hasattr(ev, "verbose"):
+            await ctx.set("verbose", ev.verbose)
+        else:
+            await ctx.set("verbose", False)
+
+        llm = await ctx.get("llm")
+        response = llm.complete(
+            f"""
+            Given a user question, and a list of tools, output a list of
+            relevant sub-questions, such that the answers to all the
+            sub-questions put together will answer the question.
+            Order the sub-questions in the right order if there are dependencies.
+            Make sure sub-questions do not result in duplicate tool calling.
+            Respond in pure JSON without any markdown, like this:
+            {{
+                "sub_questions": [
+                    "What is the population of San Francisco?",
+                    "What is the budget of San Francisco?",
+                    "What is the GDP of San Francisco?"
+                ]
+            }}
+            As an example, for the question
+            "what is the name of the mayor of the largest city within 50 miles of San Francisco?",
+            the sub-questions could be:
+            - What is the largest city within 50 miles of San Francisco? (answer is San Jose)
+            - What is the name of the mayor of San Jose?
+            Here is the user question: {await ctx.get('original_query')}.
+            Here are previous chat messages: {chat_history}.
+            And here is the list of tools: {await ctx.get('tools')}
+            """,
+        )
+
+        if await ctx.get("verbose"):
+            print(f"Sub-questions are {response}")
+
+        response_obj = json.loads(str(response))
+        sub_questions = response_obj["sub_questions"]
+
+        await ctx.set("sub_question_count", len(sub_questions))
+
+        for question in sub_questions:
+            ctx.send_event(self.QueryEvent(question=question))
+
+        return None
+
+    @step(num_workers=3)
+    async def sub_question(self, ctx: Context, ev: QueryEvent) -> AnswerEvent:
+        """
+        Given a sub-question, return the answer to the sub-question, using the agent.
+        """
+        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))
+
+    @step
+    async def combine_answers(
+        self, ctx: Context, ev: AnswerEvent
+    ) -> StopEvent | None:
+        """
+        Given a list of answers to sub-questions, combine them into a single answer.
+        """
+        ready = ctx.collect_events(
+            ev, [self.AnswerEvent] * await ctx.get("sub_question_count")
+        )
+        if ready is None:
+            return None
+
+        answers = "\n\n".join(
+            [
+                f"Question: {event.question}: \n Answer: {event.answer}"
+                for event in ready
+            ]
+        )
+
+        prompt = f"""
+            You are given an overall question that has been split into sub-questions,
+            each of which has been answered. Combine the answers to all the sub-questions
+            into a single answer to the original question.
+
+            Original question: {await ctx.get('original_query')}
+
+            Sub-questions and answers:
+            {answers}
+        """
+        if await ctx.get("verbose"):
+            print(f"Final prompt is {prompt}")
+
+        llm = await ctx.get("llm")
+        response = llm.complete(prompt)
+
+        if await ctx.get("verbose"):
+            print("Final response is", response)
+
+        output = self.OutputsModel(response=str(response))
+        return StopEvent(result=output)
+
+class SequentialSubQuestionsWorkflow(Workflow):
+    """
+    Workflow for breaking a query into sequential sub-questions
+    """
+
+    # Workflow inputs/outputs
+    class InputsModel(BaseModel):
+        """
+        Inputs for the workflow.
+        """
+        query: str
+
+    class OutputsModel(BaseModel):
+        """
+        Outputs for the workflow.
+        """
+        response: str
+
+    # Workflow Event types
+    class QueryEvent(Event):
+        """Event for a query."""
+        question: str
+        prev_answer: str
+        num: int
+
+    @step
+    async def query(self, ctx: Context, ev: StartEvent) -> QueryEvent:
+        """
+        Given a user question, and a list of tools, output a list of relevant
+        sub-questions, such that each question depends on the response of the
+        previous question, to answer the original user question.
+        """
+        if not hasattr(ev, "inputs"):
+            raise ValueError("No inputs provided to workflow Start Event.")
+        if hasattr(ev, "inputs") and not isinstance(ev.inputs, self.InputsModel):
+            raise ValueError(f"Expected inputs to be of type {self.InputsModel}")
+        if hasattr(ev, "inputs"):
+            query = ev.inputs.query
+            await ctx.set("original_query", query)
+
+        if hasattr(ev, "agent"):
+            await ctx.set("agent", ev.agent)
+        else:
+            raise ValueError("Agent not provided to workflow Start Event.")
+        chat_history = [str(msg) for msg in ev.agent.memory.get()]
+
+        if hasattr(ev, "llm"):
+            await ctx.set("llm", ev.llm)
+        else:
+            raise ValueError("LLM not provided to workflow Start Event.")
+
+        if hasattr(ev, "tools"):
+            await ctx.set("tools", ev.tools)
+        else:
+            raise ValueError("Tools not provided to workflow Start Event.")
+
+        if hasattr(ev, "verbose"):
+            await ctx.set("verbose", ev.verbose)
+        else:
+            await ctx.set("verbose", False)
+        if ev.verbose:
+            print(f"Query is {await ctx.get('original_query')}")
+
+        llm = await ctx.get("llm")
+        response = llm.complete(
+            f"""
+            Given a user question, and a list of tools, output a list of
+            relevant sequential sub-questions, such that the answers to all the
+            sub-questions in sequence will answer the question, and the output
+            of each question can be used as input to the subsequent question.
+            Respond in pure JSON without any markdown, like this:
+            {{
+                "sub_questions": [
+                    "What is the population of San Francisco?",
+                    "Is that population larger than the population of San Jose?",
+                ]
+            }}
+            As an example, for the question
+            "what is the name of the mayor of the largest city within 50 miles of San Francisco?",
+            the sub-questions could be:
+            - What is the largest city within 50 miles of San Francisco? (answer is San Jose)
+            - What is the name of the mayor of San Jose?
+            Here is the user question: {await ctx.get('original_query')}.
+            Here are previous chat messages: {chat_history}.
+            And here is the list of tools: {await ctx.get('tools')}
+            """,
+        )
+
+        response_obj = json.loads(str(response))
+        sub_questions = response_obj["sub_questions"]
+
+        await ctx.set("sub_questions", sub_questions)
+        if await ctx.get("verbose"):
+            print(f"Sub-questions are {sub_questions}")
+
+        return self.QueryEvent(question=sub_questions[0], prev_answer="", num=0)
+
+    @step
+    async def sub_question(self, ctx: Context, ev: QueryEvent) -> StopEvent | QueryEvent:
+        """
+        Given a sub-question, return the answer to the sub-question, using the agent.
+        """
+        if await ctx.get("verbose"):
+            print(f"Sub-question is {ev.question}")
+        agent = await ctx.get("agent")
+        response = await agent.achat(ev.question)
+        if await ctx.get("verbose"):
+            print(f"Answer is {response}")
+
+        sub_questions = await ctx.get("sub_questions")
+        if ev.num + 1 < len(sub_questions):
+            return self.QueryEvent(
+                question=sub_questions[ev.num + 1],
+                prev_answer = response.response,
+                num=ev.num + 1)
+
+        output = self.OutputsModel(response=response.response)
+        return StopEvent(result=output)

vectara_agentic/tools.py

@@ -112,28 +112,36 @@ class VectaraTool(FunctionTool):
         return vectara_tool
 
     def __eq__(self, other):
+        if not isinstance(other, VectaraTool):
+            return False
+
         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:
+        if self.metadata.name != other.metadata.name:
             return False
 
-        # Check if fn_schema is an instance of a BaseModel or a class itself (metaclass)
-        self_schema_dict = self.metadata.fn_schema.model_fields
-        other_schema_dict = other.metadata.fn_schema.model_fields
-        is_equal = True
-        for key in self_schema_dict.keys():
-            if key not in other_schema_dict:
-                is_equal = False
-                break
-            if (
-                self_schema_dict[key].annotation != other_schema_dict[key].annotation
-                or self_schema_dict[key].description != other_schema_dict[key].description
-                or self_schema_dict[key].is_required() != other_schema_dict[key].is_required()
-            ):
-                is_equal = False
-                break
-        return is_equal
+        # If schema is a dict-like object, compare the dict representation
+        try:
+            # Try to get schema as dict if possible
+            if hasattr(self.metadata.fn_schema, 'schema'):
+                self_schema = self.metadata.fn_schema.schema
+                other_schema = other.metadata.fn_schema.schema
+
+                # Compare only properties and required fields
+                self_props = self_schema.get('properties', {})
+                other_props = other_schema.get('properties', {})
+
+                self_required = self_schema.get('required', [])
+                other_required = other_schema.get('required', [])
+
+                return (self_props.keys() == other_props.keys() and
+                        set(self_required) == set(other_required))
+        except Exception:
+            # If any exception occurs during schema comparison, fall back to name comparison
+            pass
+
+        return True
 
     def call(
         self, *args: Any, ctx: Optional[Context] = None, **kwargs: Any
@@ -312,6 +320,8 @@ class VectaraToolFactory:
         self.vectara_corpus_key = vectara_corpus_key
         self.vectara_api_key = vectara_api_key
         self.num_corpora = len(vectara_corpus_key.split(","))
+        self.cache_expiry = 60 * 60  # 1 hour
+        self.max_cache_size = 128
 
     def create_search_tool(
         self,
@@ -443,7 +453,7 @@ class VectaraToolFactory:
                 if doc.id_ in unique_ids:
                     continue
                 unique_ids.add(doc.id_)
-                tool_output += f"document '{doc.id_}' metadata: {doc.metadata}\n"
+                tool_output += f"document_id: '{doc.id_}'\nmetadata: '{doc.metadata}'\n"
             out = ToolOutput(
                 tool_name=search_function.__name__,
                 content=tool_output,
@@ -479,10 +489,13 @@ class VectaraToolFactory:
         function_str = f"{tool_name}({args_str}) -> str"
 
         # Create the tool
+        search_tool_extra_desc = """
+        The response includes metadata about each relevant document, but NOT the text itself.
+        """
         tool = VectaraTool.from_defaults(
             fn=search_function,
             name=tool_name,
-            description=function_str + ". " + tool_description,
+            description=function_str + "\n" + tool_description + '\n' + search_tool_extra_desc,
             fn_schema=tool_args_schema,
             tool_type=ToolType.QUERY,
         )
@@ -623,8 +636,8 @@ class VectaraToolFactory:
                 mmr_diversity_bias=mmr_diversity_bias,
                 udf_expression=udf_expression,
                 rerank_chain=rerank_chain,
-                n_sentence_before=n_sentences_before,
-                n_sentence_after=n_sentences_after,
+                n_sentences_before=n_sentences_before,
+                n_sentences_after=n_sentences_after,
                 offset=offset,
                 lambda_val=lambda_val,
                 semantics=semantics,

vectara_agentic/types.py

@@ -57,6 +57,11 @@ class ToolType(Enum):
     QUERY = "query"
     ACTION = "action"
 
+class AgentConfigType(Enum):
+    """Enumeration for different types of agent configurations."""
+    DEFAULT = "default"
+    FALLBACK = "fallback"
+
 
 # classes for Agent responses
 ToolOutput = LI_ToolOutput

vectara_agentic/utils.py

@@ -17,13 +17,13 @@ from .agent_config import AgentConfig
 
 provider_to_default_model_name = {
     ModelProvider.OPENAI: "gpt-4o",
-    ModelProvider.ANTHROPIC: "claude-3-5-sonnet-20241022",
+    ModelProvider.ANTHROPIC: "claude-3-7-sonnet-20250219",
     ModelProvider.TOGETHER: "meta-llama/Llama-3.3-70B-Instruct-Turbo",
     ModelProvider.GROQ: "llama-3.3-70b-versatile",
     ModelProvider.FIREWORKS: "accounts/fireworks/models/firefunction-v2",
     ModelProvider.BEDROCK: "anthropic.claude-3-5-sonnet-20241022-v2:0",
     ModelProvider.COHERE: "command-r-plus",
-    ModelProvider.GEMINI: "models/gemini-1.5-flash",
+    ModelProvider.GEMINI: "models/gemini-2.0-flash",
 }
 
 DEFAULT_MODEL_PROVIDER = ModelProvider.OPENAI
@@ -92,7 +92,9 @@ def get_llm(
     """
     model_provider, model_name = _get_llm_params_for_role(role, config)
     if model_provider == ModelProvider.OPENAI:
-        llm = OpenAI(model=model_name, temperature=0, is_function_calling_model=True)
+        llm = OpenAI(model=model_name, temperature=0,
+                     is_function_calling_model=True,
+                     strict=True)
     elif model_provider == ModelProvider.ANTHROPIC:
         llm = Anthropic(model=model_name, temperature=0)
     elif model_provider == ModelProvider.GEMINI:

{vectara_agentic-0.2.4.dist-info → vectara_agentic-0.2.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: vectara_agentic
-Version: 0.2.4
+Version: 0.2.6
 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,13 +16,13 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: llama-index==0.12.22
-Requires-Dist: llama-index-indices-managed-vectara==0.4.1
+Requires-Dist: llama-index==0.12.25
+Requires-Dist: llama-index-indices-managed-vectara==0.4.2
 Requires-Dist: llama-index-agent-llm-compiler==0.3.0
 Requires-Dist: llama-index-agent-lats==0.3.0
 Requires-Dist: llama-index-agent-openai==0.4.6
 Requires-Dist: llama-index-llms-openai==0.3.25
-Requires-Dist: llama-index-llms-anthropic==0.6.7
+Requires-Dist: llama-index-llms-anthropic==0.6.10
 Requires-Dist: llama-index-llms-together==0.3.1
 Requires-Dist: llama-index-llms-groq==0.3.1
 Requires-Dist: llama-index-llms-fireworks==0.3.2
@@ -41,18 +41,18 @@ Requires-Dist: llama-index-tools-exa==0.3.0
 Requires-Dist: tavily-python==0.5.1
 Requires-Dist: exa-py==1.8.9
 Requires-Dist: yahoo-finance==1.4.0
-Requires-Dist: openinference-instrumentation-llama-index==3.1.4
-Requires-Dist: opentelemetry-proto==1.26.0
-Requires-Dist: arize-phoenix==7.11.0
-Requires-Dist: arize-phoenix-otel==0.6.1
-Requires-Dist: protobuf==4.25.5
+Requires-Dist: openinference-instrumentation-llama-index==3.3.3
+Requires-Dist: opentelemetry-proto==1.31.0
+Requires-Dist: arize-phoenix==8.14.1
+Requires-Dist: arize-phoenix-otel==0.8.0
+Requires-Dist: protobuf==5.29.3
 Requires-Dist: tokenizers>=0.20
-Requires-Dist: pydantic==2.10.3
+Requires-Dist: pydantic==2.10.6
 Requires-Dist: retrying==1.3.4
 Requires-Dist: python-dotenv==1.0.1
 Requires-Dist: tiktoken==0.9.0
 Requires-Dist: cloudpickle>=3.1.1
-Requires-Dist: httpx==0.27.2
+Requires-Dist: httpx==0.28.1
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier
@@ -60,6 +60,7 @@ Dynamic: description
 Dynamic: description-content-type
 Dynamic: home-page
 Dynamic: keywords
+Dynamic: license-file
 Dynamic: project-url
 Dynamic: requires-dist
 Dynamic: requires-python
@@ -93,14 +94,20 @@ Dynamic: summary
 <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 or search tool with a single line of code.
-- Supports `ReAct`, `OpenAIAgent`, `LATS` and `LLMCompiler` agent types.
-- Includes pre-built tools for various domains (e.g., finance, legal).
-- Integrates with various LLM inference services like OpenAI, Anthropic, Gemini, GROQ, Together.AI, Cohere, Bedrock and Fireworks
-- Built-in support for observability with Arize Phoenix
+### Key Features
+
+- **Rapid Tool Creation:**  
+  Build Vectara RAG tools or search tools with a single line of code.
+- **Agent Flexibility:**  
+  Supports multiple agent types including `ReAct`, `OpenAIAgent`, `LATS`, and `LLMCompiler`.
+- **Pre-Built Domain Tools:**  
+  Tools tailored for finance, legal, and other verticals.
+- **Multi-LLM Integration:**  
+  Seamless integration with OpenAI, Anthropic, Gemini, GROQ, Together.AI, Cohere, Bedrock, and Fireworks.
+- **Observability:**  
+  Built-in support with Arize Phoenix for monitoring and feedback.
+- **Workflow Support:**  
+  Extend your agent’s capabilities by defining custom workflows using the `run()` method.
 
 ### 📚 Example AI Assistants
 
@@ -200,7 +207,7 @@ agent = Agent(
 
 See the [docs](https://vectara.github.io/vectara-agentic-docs/) for additional arguments, including `agent_progress_callback` and `query_logging_callback`.
 
-### 5. Run your agent
+### 5. Run a chat interaction
 
 ```python
 res = agent.chat("What was the revenue for Apple in 2021?")
@@ -213,6 +220,77 @@ Note that:
    response it's available as the `response` variable, or just use `str()`. For advanced use-cases you can look 
    at other `AgentResponse` variables [such as `sources`](https://github.com/run-llama/llama_index/blob/659f9faaafbecebb6e6c65f42143c0bf19274a37/llama-index-core/llama_index/core/chat_engine/types.py#L53).
 
+## Advanced Usage: Workflows
+
+In addition to standard chat interactions, `vectara-agentic` supports custom workflows via the `run()` method. 
+Workflows allow you to structure multi-step interactions where inputs and outputs are validated using Pydantic models.
+To learn more about workflows read [the documentation](https://docs.llamaindex.ai/en/stable/understanding/workflows/basic_flow/)
+
+### Defining a Custom Workflow
+
+Create a workflow by subclassing `llama_index.core.workflow.Workflow` and defining the input/output models:
+
+```python
+from pydantic import BaseModel
+from llama_index.core.workflow import (
+    StartEvent,StopEvent, Workflow, step,
+)
+
+class MyWorkflow(Workflow):
+    class InputsModel(BaseModel):
+        query: str
+
+    class OutputsModel(BaseModel):
+        answer: str
+
+    @step
+    async def my_step(self, ev: StartEvent) -> StopEvent:
+        # do something here
+        return StopEvent(result="Hello, world!")
+```
+
+When the `run()` method in vectara-agentic is invoked, it calls the workflow with the following variables in the StartEvent:
+* `agent`: the agent object used to call `run()` (self)
+* `tools`: the tools provided to the agent. Those can be used as needed in the flow.
+* `llm`: a pointer to a LlamaIndex llm, so it can be used in the workflow. For example, one of the steps may call `llm.acomplete(prompt)`
+* `verbose`: controls whether extra debug information is displayed
+* `inputs`: this is the actual inputs to the workflow provided by the call to `run()` and must be of type `InputsModel`
+
+### Using the Workflow with Your Agent
+
+When initializing your agent, pass the workflow class using the `workflow_cls` parameter:
+
+```python
+agent = Agent(
+    tools=[query_financial_reports_tool],
+    topic="10-K financial reports",
+    custom_instructions="You are a helpful financial assistant.",
+    workflow_cls=MyWorkflow,       # Provide your custom workflow here
+    workflow_timeout=120           # Optional: Set a timeout (default is 120 seconds)
+)
+```
+
+### Running the Workflow
+
+Prepare the inputs using your workflow’s `InputsModel` and execute the workflow using `run()`:
+
+```python
+# Create an instance of the workflow's input model
+inputs = MyWorkflow.InputsModel(query="What is Vectara?", extra_param=42)
+
+# Run the workflow (ensure you're in an async context or use asyncio.run)
+workflow_result = asyncio.run(agent.run(inputs))
+
+# Access the output from the workflow's OutputsModel
+print(workflow_result.answer)
+```
+
+### Using SubQuestionQueryWorkflow
+
+vectara-agentic already includes one useful workflow you can use right away (it is also useful as an advanced example)
+This workflow is called `SubQuestionQueryWorkflow` and it works by breaking a complex query into sub-queries and then
+executing each sub-query with the agent until it reaches a good response.
+
 ## 🧰 Vectara tools
 
 `vectara-agentic` provides two helper functions to connect with Vectara RAG
@@ -353,9 +431,9 @@ The `AgentConfig` object may include the following items:
 
 If any of these are not provided, `AgentConfig` first tries to read the values from the OS environment.
 
-## Configuring Vectara RAG or search tools
+## Configuring Vectara tools: rag_tool, or search_tool
 
-When creating a `VectaraToolFactory`, you can pass in a `vectara_api_key`, `vectara_customer_id`, and `vectara_corpus_id` to the factory. 
+When creating a `VectaraToolFactory`, you can pass in a `vectara_api_key`, and `vectara_corpus_key` to the factory. 
 
 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).
 

vectara_agentic-0.2.6.dist-info/RECORD

@@ -0,0 +1,28 @@
+tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/endpoint.py,sha256=frnpdZQpnuQNNKNYgAn2rFTarNG8MCJaNA77Bw_W22A,1420
+tests/test_agent.py,sha256=5iYlROsGQV_fPF9IR1JZ_ByhQ3EoaLG_40ntrCgugWo,6461
+tests/test_agent_planning.py,sha256=0GEI-b7g5tV8xP_FbTfIu-a8J9s_EhDXC_9T6HS6DsU,1457
+tests/test_agent_type.py,sha256=-14Y6vwYTaRJuj8VZ-c6d1vIiWpV31k2zs_frdoxR5s,2920
+tests/test_fallback.py,sha256=4ZqP_7XsabhzaVgXa599PDbwp38t_XY5fMzQwr8F6Z8,2793
+tests/test_private_llm.py,sha256=rPXQ-NKL2MnrMcGNEG1Zz3U8uK9pjxUfjvIl2gH9gnw,2224
+tests/test_tools.py,sha256=0-2oWX8DW0WIjViNFl0xj_6JOhIdyx6zV0IlTuMzxjk,3954
+tests/test_workflow.py,sha256=lVyrVHdRO5leYNbYtHTmKqMX0c8_xehCpUA7cXQKVsc,2175
+vectara_agentic/__init__.py,sha256=2GLDS3U6KckK-dBRl9v_x1kSV507gEhjOfuMmmu0Qxg,850
+vectara_agentic/_callback.py,sha256=5PfqjLmuaZIR6dnqmhniTD_zwCgfi7kOu-nexb6Kss4,9688
+vectara_agentic/_observability.py,sha256=fTL3KW0jQU-_JSpFgjO6-XzgDut_oiq9kt4QR-FkSqU,3804
+vectara_agentic/_prompts.py,sha256=LYyiOAiC8imz3U7MSJiuCYAP39afsp7ycXY7-9biyJI,9314
+vectara_agentic/_version.py,sha256=EFHZPv0y0xF__sBHhCA8j-o21yOSHXl15GJEp-lZLy4,65
+vectara_agentic/agent.py,sha256=74_2XzBvl5jPyAqqYhoxsS7PXITWBdJpxs4L_XeyZio,42561
+vectara_agentic/agent_config.py,sha256=y1hSvU5ns0cE2R7BqF65LFstixF1ytJcoVgicGXo7w0,3691
+vectara_agentic/agent_endpoint.py,sha256=QIMejCLlpW2qzXxeDAxv3anF46XMDdVMdKGWhJh3azY,1996
+vectara_agentic/db_tools.py,sha256=VUdcjDFPwauFd2A92mXNYZnCjeMiTzcTka7S5At_3oQ,3595
+vectara_agentic/sub_query_workflow.py,sha256=KcIfUaDcv25n8iLQmZ9ZhNlKyZAKAu-3otXADukBios,10394
+vectara_agentic/tools.py,sha256=xWxl1ixSCsBPjZ-GNpkjN_nXRBxvH_vr8oDauAYrIW0,41763
+vectara_agentic/tools_catalog.py,sha256=oiw3wAfbpFhh0_6rMvZsyPqWV6QIzHqhZCNzqRxuyV8,4818
+vectara_agentic/types.py,sha256=tLpyDY-UbFN2Iqk_fgWoOxlGexh_AQ5BaXQ593sCkRc,1750
+vectara_agentic/utils.py,sha256=AUyWrL8aY67AGx6j9m00k75JRHTI44EAKtal73aMczM,5504
+vectara_agentic-0.2.6.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+vectara_agentic-0.2.6.dist-info/METADATA,sha256=u9gIGxK3XEPeSItrUevqwJVOWWzRJ3Mqdo55-l3o098,25046
+vectara_agentic-0.2.6.dist-info/WHEEL,sha256=1tXe9gY0PYatrMPMDd6jXqjfpz_B-Wqm32CPfRC58XU,91
+vectara_agentic-0.2.6.dist-info/top_level.txt,sha256=Y7TQTFdOYGYodQRltUGRieZKIYuzeZj2kHqAUpfCUfg,22
+vectara_agentic-0.2.6.dist-info/RECORD,,

{vectara_agentic-0.2.4.dist-info → vectara_agentic-0.2.6.dist-info}/WHEEL

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