vectara-agentic 0.2.13__tar.gz → 0.2.14__tar.gz

{vectara_agentic-0.2.13/vectara_agentic.egg-info → vectara_agentic-0.2.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vectara_agentic
-Version: 0.2.13
+Version: 0.2.14
 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,18 +16,18 @@ 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.31
-Requires-Dist: llama-index-indices-managed-vectara==0.4.3
+Requires-Dist: llama-index==0.12.33
+Requires-Dist: llama-index-indices-managed-vectara==0.4.4
 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.35
+Requires-Dist: llama-index-llms-openai==0.3.38
 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
 Requires-Dist: llama-index-llms-cohere==0.4.1
-Requires-Dist: llama-index-llms-gemini==0.4.14
+Requires-Dist: llama-index-llms-google-genai==0.1.8
 Requires-Dist: llama-index-llms-bedrock==0.3.8
 Requires-Dist: llama-index-tools-yahoo-finance==0.3.0
 Requires-Dist: llama-index-tools-arxiv==0.3.0
@@ -49,7 +49,7 @@ Requires-Dist: arize-phoenix==8.26.1
 Requires-Dist: arize-phoenix-otel==0.9.2
 Requires-Dist: protobuf==5.29.3
 Requires-Dist: tokenizers>=0.20
-Requires-Dist: pydantic==2.10.6
+Requires-Dist: pydantic==2.11.3
 Requires-Dist: retrying==1.3.4
 Requires-Dist: python-dotenv==1.0.1
 Requires-Dist: tiktoken==0.9.0
@@ -292,13 +292,12 @@ For example, in the quickstart example the schema is:
 
 ```python
 class QueryFinancialReportsArgs(BaseModel):
-    query: str = Field(..., description="The user query.")
     year: int | str = Field(..., description=f"The year this query relates to. An integer between {min(years)} and {max(years)} or a string specifying a condition on the year (example: '>2020').")
     ticker: str = Field(..., description=f"The company ticker. Must be a valid ticket symbol from the list {tickers.keys()}.")
 ```
 
-The `query` is required and is always the query string.
-The other arguments are optional and will be interpreted as Vectara metadata filters.
+Remember, the `query` argument is part of the rag_tool that is generated, but `vectara-agentic` creates it and you do 
+not need to specify it explicitly. 
 
 For example, in the example above, the agent may call the `query_financial_reports_tool` tool with 
 query='what is the revenue?', year=2022 and ticker='AAPL'. Subsequently the RAG tool will issue
@@ -483,13 +482,28 @@ class MyWorkflow(Workflow):
         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:
+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`
 
+If you want to use `agent`, `tools`, `llm` or `verbose` in other events (that are not `StartEvent`), you can store them in
+the `Context` of the Workflow as follows:
+
+```python
+await ctx.set("agent", ev.agent)
+```
+
+and then in any other event you can pull that agent object with
+
+```python
+agent = await ctx.get("agent")
+```
+
+Similarly you can reuse the `llm`, `tools` or `verbose` arguments within other nodes in the workflow.
+
 ### Using the Workflow with Your Agent
 
 When initializing your agent, pass the workflow class using the `workflow_cls` parameter:
@@ -521,7 +535,7 @@ print(workflow_result.answer)
 
 ### Built-in Workflows
 
-`vectara-agentic` includes two powerful workflow implementations that you can use right away:
+`vectara-agentic` includes two workflow implementations that you can use right away:
 
 #### 1. `SubQuestionQueryWorkflow`
 

{vectara_agentic-0.2.13 → vectara_agentic-0.2.14}/README.md

@@ -222,13 +222,12 @@ For example, in the quickstart example the schema is:
 
 ```python
 class QueryFinancialReportsArgs(BaseModel):
-    query: str = Field(..., description="The user query.")
     year: int | str = Field(..., description=f"The year this query relates to. An integer between {min(years)} and {max(years)} or a string specifying a condition on the year (example: '>2020').")
     ticker: str = Field(..., description=f"The company ticker. Must be a valid ticket symbol from the list {tickers.keys()}.")
 ```
 
-The `query` is required and is always the query string.
-The other arguments are optional and will be interpreted as Vectara metadata filters.
+Remember, the `query` argument is part of the rag_tool that is generated, but `vectara-agentic` creates it and you do 
+not need to specify it explicitly. 
 
 For example, in the example above, the agent may call the `query_financial_reports_tool` tool with 
 query='what is the revenue?', year=2022 and ticker='AAPL'. Subsequently the RAG tool will issue
@@ -413,13 +412,28 @@ class MyWorkflow(Workflow):
         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:
+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`
 
+If you want to use `agent`, `tools`, `llm` or `verbose` in other events (that are not `StartEvent`), you can store them in
+the `Context` of the Workflow as follows:
+
+```python
+await ctx.set("agent", ev.agent)
+```
+
+and then in any other event you can pull that agent object with
+
+```python
+agent = await ctx.get("agent")
+```
+
+Similarly you can reuse the `llm`, `tools` or `verbose` arguments within other nodes in the workflow.
+
 ### Using the Workflow with Your Agent
 
 When initializing your agent, pass the workflow class using the `workflow_cls` parameter:
@@ -451,7 +465,7 @@ print(workflow_result.answer)
 
 ### Built-in Workflows
 
-`vectara-agentic` includes two powerful workflow implementations that you can use right away:
+`vectara-agentic` includes two workflow implementations that you can use right away:
 
 #### 1. `SubQuestionQueryWorkflow`
 

{vectara_agentic-0.2.13 → vectara_agentic-0.2.14}/requirements.txt

@@ -1,15 +1,15 @@
-llama-index==0.12.31
-llama-index-indices-managed-vectara==0.4.3
+llama-index==0.12.33
+llama-index-indices-managed-vectara==0.4.4
 llama-index-agent-llm-compiler==0.3.0
 llama-index-agent-lats==0.3.0
 llama-index-agent-openai==0.4.6
-llama-index-llms-openai==0.3.35
+llama-index-llms-openai==0.3.38
 llama-index-llms-anthropic==0.6.10
 llama-index-llms-together==0.3.1
 llama-index-llms-groq==0.3.1
 llama-index-llms-fireworks==0.3.2
 llama-index-llms-cohere==0.4.1
-llama-index-llms-gemini==0.4.14
+llama-index-llms-google-genai ==0.1.8
 llama-index-llms-bedrock==0.3.8
 llama-index-tools-yahoo-finance==0.3.0
 llama-index-tools-arxiv==0.3.0
@@ -31,7 +31,7 @@ arize-phoenix==8.26.1
 arize-phoenix-otel==0.9.2
 protobuf==5.29.3
 tokenizers>=0.20
-pydantic==2.10.6
+pydantic==2.11.3
 retrying==1.3.4
 python-dotenv==1.0.1
 tiktoken==0.9.0

vectara_agentic-0.2.14/tests/test_groq.py

@@ -0,0 +1,120 @@
+import unittest
+
+from pydantic import Field, BaseModel
+
+from vectara_agentic.agent import Agent, AgentType
+from vectara_agentic.agent_config import AgentConfig
+from vectara_agentic.tools import VectaraToolFactory
+from vectara_agentic.types import ModelProvider
+
+
+import nest_asyncio
+nest_asyncio.apply()
+
+tickers = {
+    "C": "Citigroup",
+    "COF": "Capital One",
+    "JPM": "JPMorgan Chase",
+    "AAPL": "Apple Computer",
+    "GOOG": "Google",
+    "AMZN": "Amazon",
+    "SNOW": "Snowflake",
+    "TEAM": "Atlassian",
+    "TSLA": "Tesla",
+    "NVDA": "Nvidia",
+    "MSFT": "Microsoft",
+    "AMD": "Advanced Micro Devices",
+    "INTC": "Intel",
+    "NFLX": "Netflix",
+    "STT": "State Street",
+    "BK": "Bank of New York Mellon",
+}
+years = list(range(2015, 2025))
+
+
+def mult(x: float, y: float) -> float:
+    "Multiply two numbers"
+    return x * y
+
+
+def get_company_info() -> list[str]:
+    """
+    Returns a dictionary of companies you can query about. Always check this before using any other tool.
+    The output is a dictionary of valid ticker symbols mapped to company names.
+    You can use this to identify the companies you can query about, and their ticker information.
+    """
+    return tickers
+
+
+def get_valid_years() -> list[str]:
+    """
+    Returns a list of the years for which financial reports are available.
+    Always check this before using any other tool.
+    """
+    return years
+
+
+config_gemini = AgentConfig(
+    agent_type=AgentType.FUNCTION_CALLING,
+    main_llm_provider=ModelProvider.GEMINI,
+    tool_llm_provider=ModelProvider.GEMINI,
+)
+
+
+fc_config_groq = AgentConfig(
+    agent_type=AgentType.FUNCTION_CALLING,
+    main_llm_provider=ModelProvider.GROQ,
+    tool_llm_provider=ModelProvider.GROQ,
+)
+
+
+class TestGROQ(unittest.TestCase):
+
+    def test_tool_with_many_arguments(self):
+
+        vectara_corpus_key = "vectara-docs_1"
+        vectara_api_key = "zqt_UXrBcnI2UXINZkrv4g1tQPhzj02vfdtqYJIDiA"
+        vec_factory = VectaraToolFactory(vectara_corpus_key, vectara_api_key)
+
+        class QueryToolArgs(BaseModel):
+            arg1: str = Field(description="the first argument", examples=["val1"])
+            arg2: str = Field(description="the second argument", examples=["val2"])
+            arg3: str = Field(description="the third argument", examples=["val3"])
+            arg4: str = Field(description="the fourth argument", examples=["val4"])
+            arg5: str = Field(description="the fifth argument", examples=["val5"])
+            arg6: str = Field(description="the sixth argument", examples=["val6"])
+            arg7: str = Field(description="the seventh argument", examples=["val7"])
+            arg8: str = Field(description="the eighth argument", examples=["val8"])
+            arg9: str = Field(description="the ninth argument", examples=["val9"])
+            arg10: str = Field(description="the tenth argument", examples=["val10"])
+            arg11: str = Field(description="the eleventh argument", examples=["val11"])
+            arg12: str = Field(description="the twelfth argument", examples=["val12"])
+            arg13: str = Field(
+                description="the thirteenth argument", examples=["val13"]
+            )
+            arg14: str = Field(
+                description="the fourteenth argument", examples=["val14"]
+            )
+            arg15: str = Field(description="the fifteenth argument", examples=["val15"])
+
+        query_tool_1 = vec_factory.create_rag_tool(
+            tool_name="rag_tool",
+            tool_description="""
+            A dummy tool that takes 15 arguments and returns a response (str) to the user query based on the data in this corpus.
+            We are using this tool to test the tool factory works and does not crash with OpenAI.
+            """,
+            tool_args_schema=QueryToolArgs,
+        )
+
+        agent = Agent(
+            tools=[query_tool_1],
+            topic="Sample topic",
+            custom_instructions="Call the tool with 15 arguments",
+            agent_config=fc_config_groq,
+        )
+        res = agent.chat("What is the stock price?")
+        self.assertIn("I don't know", str(res))
+
+
+if __name__ == "__main__":
+    unittest.main()

{vectara_agentic-0.2.13 → vectara_agentic-0.2.14}/tests/test_tools.py

@@ -9,6 +9,7 @@ from vectara_agentic.tools import (
 )
 from vectara_agentic.agent import Agent
 from vectara_agentic.agent_config import AgentConfig
+from vectara_agentic.types import AgentType, ModelProvider
 
 from llama_index.core.tools import FunctionTool
 
@@ -179,22 +180,57 @@ class TestToolsPackage(unittest.TestCase):
         query_tool_1 = vec_factory.create_rag_tool(
             tool_name="rag_tool",
             tool_description="""
-            A dummy tool that takes 20 arguments and returns a response (str) to the user query based on the data in this corpus.
+            A dummy tool that takes 15 arguments and returns a response (str) to the user query based on the data in this corpus.
             We are using this tool to test the tool factory works and does not crash with OpenAI.
             """,
             tool_args_schema=QueryToolArgs,
         )
 
-        config = AgentConfig()
+        # Test with 15 arguments which go over the 1024 limit.
+        config = AgentConfig(
+            agent_type=AgentType.OPENAI
+        )
         agent = Agent(
             tools=[query_tool_1],
             topic="Sample topic",
-            custom_instructions="Call the tool with 20 arguments",
+            custom_instructions="Call the tool with 15 arguments for OPENAI",
             agent_config=config,
         )
         res = agent.chat("What is the stock price?")
         self.assertIn("maximum length of 1024 characters", str(res))
 
+        # Same test but with GROQ
+        config = AgentConfig(
+            agent_type=AgentType.FUNCTION_CALLING,
+            main_llm_provider=ModelProvider.GROQ,
+            tool_llm_provider=ModelProvider.GROQ,
+        )
+        agent = Agent(
+            tools=[query_tool_1],
+            topic="Sample topic",
+            custom_instructions="Call the tool with 15 arguments for GROQ",
+            agent_config=config,
+        )
+        res = agent.chat("What is the stock price?")
+        self.assertNotIn("maximum length of 1024 characters", str(res))
+
+        # Same test but with ANTHROPIC
+        config = AgentConfig(
+            agent_type=AgentType.FUNCTION_CALLING,
+            main_llm_provider=ModelProvider.ANTHROPIC,
+            tool_llm_provider=ModelProvider.ANTHROPIC,
+        )
+        agent = Agent(
+            tools=[query_tool_1],
+            topic="Sample topic",
+            custom_instructions="Call the tool with 15 arguments for ANTHROPIC",
+            agent_config=config,
+        )
+        res = agent.chat("What is the stock price?")
+        # ANTHROPIC does not have that 1024 limit
+        self.assertIn("stock price", str(res))
+
+        # But using Compact_docstring=True, we can pass 15 arguments successfully.
         vec_factory = VectaraToolFactory(
             vectara_corpus_key, vectara_api_key, compact_docstring=True
         )
@@ -211,7 +247,7 @@ class TestToolsPackage(unittest.TestCase):
         agent = Agent(
             tools=[query_tool_2],
             topic="Sample topic",
-            custom_instructions="Call the tool with 20 arguments",
+            custom_instructions="Call the tool with 15 arguments",
             agent_config=config,
         )
         res = agent.chat("What is the stock price?")
@@ -227,7 +263,7 @@ class TestToolsPackage(unittest.TestCase):
             tool_name="ask_vectara",
             data_description="data from Vectara website",
             assistant_specialty="RAG as a service",
-            vectara_summarizer="mockingbird-1.0-2024-07-16",
+            vectara_summarizer="mockingbird-2.0",
         )
 
         self.assertIn(

{vectara_agentic-0.2.13 → vectara_agentic-0.2.14}/tests/test_vectara_llms.py

@@ -51,17 +51,6 @@ class TestLLMPackage(unittest.TestCase):
 
     def test_vectara_mockingbird(self):
         vec_factory = VectaraToolFactory(vectara_corpus_key, vectara_api_key)
-
-        query_tool = vec_factory.create_rag_tool(
-            tool_name="rag_tool",
-            tool_description="""
-            Returns a response (str) to the user query based on the data in this corpus.
-            """,
-            vectara_summarizer="mockingbird-1.0-2024-07-16",
-        )
-        res = query_tool(query="What is Vectara?")
-        self.assertIn("Vectara is an end-to-end platform", str(res))
-
         query_tool = vec_factory.create_rag_tool(
             tool_name="rag_tool",
             tool_description="""

{vectara_agentic-0.2.13 → vectara_agentic-0.2.14}/vectara_agentic/_version.py

@@ -1,4 +1,4 @@
 """
 Define the version of the package.
 """
-__version__ = "0.2.13"
+__version__ = "0.2.14"

{vectara_agentic-0.2.13 → vectara_agentic-0.2.14}/vectara_agentic/agent.py

@@ -12,6 +12,8 @@ import logging
 import asyncio
 import importlib
 from collections import Counter
+import inspect
+from inspect import Signature, Parameter, ismethod
 
 import cloudpickle as pickle
 
@@ -19,6 +21,7 @@ from dotenv import load_dotenv
 
 from pydantic import Field, create_model, ValidationError
 
+
 from llama_index.core.memory import ChatMemoryBuffer
 from llama_index.core.llms import ChatMessage, MessageRole
 from llama_index.core.tools import FunctionTool
@@ -47,7 +50,7 @@ from .types import (
     AgentStreamingResponse,
     AgentConfigType,
 )
-from .utils import get_llm, get_tokenizer_for_model
+from .llm_utils import get_llm, get_tokenizer_for_model
 from ._prompts import (
     REACT_PROMPT_TEMPLATE,
     GENERAL_PROMPT_TEMPLATE,
@@ -230,6 +233,10 @@ class Agent:
         self.workflow_cls = workflow_cls
         self.workflow_timeout = workflow_timeout
 
+        # Sanitize tools for Gemini if needed
+        if self.agent_config.main_llm_provider == ModelProvider.GEMINI:
+            self.tools = self._sanitize_tools_for_gemini(self.tools)
+
         # Validate tools
         # Check for:
         # 1. multiple copies of the same tool
@@ -311,6 +318,63 @@ class Agent:
             print(f"Failed to set up observer ({e}), ignoring")
             self.observability_enabled = False
 
+    def _sanitize_tools_for_gemini(
+        self, tools: list[FunctionTool]
+    ) -> list[FunctionTool]:
+        """
+        Strip all default values from:
+        - tool.fn
+        - tool.async_fn
+        - tool.metadata.fn_schema
+        so Gemini sees *only* required parameters, no defaults.
+        """
+        for tool in tools:
+            # 1) strip defaults off the actual callables
+            for func in (tool.fn, tool.async_fn):
+                if not func:
+                    continue
+                orig_sig = inspect.signature(func)
+                new_params = [
+                    p.replace(default=Parameter.empty)
+                    for p in orig_sig.parameters.values()
+                ]
+                new_sig = Signature(
+                    new_params, return_annotation=orig_sig.return_annotation
+                )
+                if ismethod(func):
+                    func.__func__.__signature__ = new_sig
+                else:
+                    func.__signature__ = new_sig
+
+            # 2) rebuild the Pydantic schema so that *every* field is required
+            schema_cls = getattr(tool.metadata, "fn_schema", None)
+            if schema_cls and hasattr(schema_cls, "model_fields"):
+                # collect (name → (type, Field(...))) for all fields
+                new_fields: dict[str, tuple[type, Any]] = {}
+                for name, mf in schema_cls.model_fields.items():
+                    typ = mf.annotation
+                    desc = getattr(mf, "description", "")
+                    # force required (no default) with Field(...)
+                    new_fields[name] = (typ, Field(..., description=desc))
+
+                # make a brand-new schema class where every field is required
+                no_default_schema = create_model(
+                    f"{schema_cls.__name__}",  # new class name
+                    **new_fields,  # type: ignore
+                )
+
+                # give it a clean __signature__ so inspect.signature sees no defaults
+                params = [
+                    Parameter(n, Parameter.POSITIONAL_OR_KEYWORD, annotation=typ)
+                    for n, (typ, _) in new_fields.items()
+                ]
+                no_default_schema.__signature__ = Signature(params)
+
+                # swap it back onto the tool
+                tool.metadata.fn_schema = no_default_schema
+
+        return tools
+
     def _create_agent(
         self, config: AgentConfig, llm_callback_manager: CallbackManager
     ) -> Union[BaseAgent, AgentRunner]:

vectara_agentic-0.2.13/vectara_agentic/utils.py → vectara_agentic-0.2.14/vectara_agentic/llm_utils.py

@@ -1,14 +1,10 @@
 """
 Utilities for the Vectara agentic.
 """
-
+from types import MethodType
 from typing import Tuple, Callable, Optional
 from functools import lru_cache
-from inspect import signature
-import json
-import asyncio
 import tiktoken
-import aiohttp
 
 from llama_index.core.llms import LLM
 from llama_index.llms.openai import OpenAI
@@ -16,6 +12,7 @@ from llama_index.llms.anthropic import Anthropic
 
 from .types import LLMRole, AgentType, ModelProvider
 from .agent_config import AgentConfig
+from .tool_utils import _updated_openai_prepare_chat_with_tools
 
 provider_to_default_model_name = {
     ModelProvider.OPENAI: "gpt-4o",
@@ -105,9 +102,9 @@ def get_llm(role: LLMRole, config: Optional[AgentConfig] = None) -> LLM:
             max_tokens=max_tokens,
         )
     elif model_provider == ModelProvider.GEMINI:
-        from llama_index.llms.gemini import Gemini
+        from llama_index.llms.google_genai import GoogleGenAI
 
-        llm = Gemini(
+        llm = GoogleGenAI(
             model=model_name,
             temperature=0,
             is_function_calling_model=True,
@@ -123,6 +120,11 @@ def get_llm(role: LLMRole, config: Optional[AgentConfig] = None) -> LLM:
             is_function_calling_model=True,
             max_tokens=max_tokens,
         )
+        # pylint: disable=protected-access
+        llm._prepare_chat_with_tools = MethodType(
+            _updated_openai_prepare_chat_with_tools,
+            llm,
+        )
     elif model_provider == ModelProvider.GROQ:
         from llama_index.llms.groq import Groq
 
@@ -132,6 +134,11 @@ def get_llm(role: LLMRole, config: Optional[AgentConfig] = None) -> LLM:
             is_function_calling_model=True,
             max_tokens=max_tokens,
         )
+        # pylint: disable=protected-access
+        llm._prepare_chat_with_tools = MethodType(
+            _updated_openai_prepare_chat_with_tools,
+            llm,
+        )
     elif model_provider == ModelProvider.FIREWORKS:
         from llama_index.llms.fireworks import Fireworks
 
@@ -156,84 +163,12 @@ def get_llm(role: LLMRole, config: Optional[AgentConfig] = None) -> LLM:
             api_key=config.private_llm_api_key,
             max_tokens=max_tokens,
         )
+        # pylint: disable=protected-access
+        llm._prepare_chat_with_tools = MethodType(
+            _updated_openai_prepare_chat_with_tools,
+            llm,
+        )
+
     else:
         raise ValueError(f"Unknown LLM provider: {model_provider}")
     return llm
-
-
-def is_float(value: str) -> bool:
-    """Check if a string can be converted to a float."""
-    try:
-        float(value)
-        return True
-    except ValueError:
-        return False
-
-
-def remove_self_from_signature(func):
-    """Decorator to remove 'self' from a method's signature for introspection."""
-    sig = signature(func)
-    params = list(sig.parameters.values())
-    # Remove the first parameter if it is named 'self'
-    if params and params[0].name == "self":
-        params = params[1:]
-    new_sig = sig.replace(parameters=params)
-    func.__signature__ = new_sig
-    return func
-
-
-async def summarize_vectara_document(
-    llm_name: str, corpus_key: str, api_key: str, doc_id: str
-) -> str:
-    """
-    Summarize a document in a Vectara corpus using the Vectara API.
-    """
-    url = f"https://api.vectara.io/v2/corpora/{corpus_key}/documents/{doc_id}/summarize"
-
-    payload = json.dumps(
-        {
-            "llm_name": llm_name,
-            "model_parameters": {"temperature": 0.0},
-            "stream_response": False,
-        }
-    )
-    headers = {
-        "Content-Type": "application/json",
-        "Accept": "application/json",
-        "x-api-key": api_key,
-    }
-    timeout = aiohttp.ClientTimeout(total=60)
-    async with aiohttp.ClientSession(timeout=timeout) as session:
-        async with session.post(url, headers=headers, data=payload) as response:
-            if response.status != 200:
-                error_json = await response.json()
-                return (
-                    f"Vectara Summarization failed with error code {response.status}, "
-                    f"error={error_json['messages'][0]}"
-                )
-            data = await response.json()
-            return data["summary"]
-    return json.loads(response.text)["summary"]
-
-
-async def summarize_documents(
-    corpus_key: str,
-    api_key: str,
-    doc_ids: list[str],
-    llm_name: str = "gpt-4o",
-) -> dict[str, str]:
-    """
-    Summarize multiple documents in a Vectara corpus using the Vectara API.
-    """
-    if not doc_ids:
-        return {}
-    if llm_name is None:
-        llm_name = "gpt-4o"
-    tasks = [
-        summarize_vectara_document(
-            corpus_key=corpus_key, api_key=api_key, llm_name=llm_name, doc_id=doc_id
-        )
-        for doc_id in doc_ids
-    ]
-    summaries = await asyncio.gather(*tasks, return_exceptions=True)
-    return dict(zip(doc_ids, summaries))