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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vectara_agentic
-Version: 0.2.21
+Version: 0.2.22
 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

{vectara_agentic-0.2.21 → vectara_agentic-0.2.22}/tests/test_agent_type.py

@@ -19,10 +19,13 @@ react_config_anthropic = AgentConfig(
     tool_llm_provider=ModelProvider.ANTHROPIC,
 )
 
+# React with Google does not work with Gemini 2.5-flash
 react_config_gemini = AgentConfig(
     agent_type=AgentType.REACT,
     main_llm_provider=ModelProvider.GEMINI,
+    main_llm_model_name="models/gemini-2.0-flash",
     tool_llm_provider=ModelProvider.GEMINI,
+    tool_llm_model_name="models/gemini-2.0-flash",
 )
 
 react_config_together = AgentConfig(
@@ -97,7 +100,7 @@ class TestAgentType(unittest.TestCase):
         )
         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 multiplications. Only give the answer, nothing else.")
+        res = agent.chat("what is the result of multiplying the results of the last two multiplications. Only give the answer, nothing else.")
         self.assertIn("1050", res.response)
 
         agent = Agent(
@@ -108,7 +111,7 @@ class TestAgentType(unittest.TestCase):
         )
         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 multiplications. Only give the answer, nothing else.")
+        res = agent.chat("what is the result of multiplying the results of the last two multiplications. Only give the answer, nothing else.")
         self.assertIn("1050", res.response)
 
     def test_together(self):

vectara_agentic-0.2.22/tests/test_groq.py

@@ -0,0 +1,42 @@
+import unittest
+
+from vectara_agentic.agent import Agent, AgentType
+from vectara_agentic.agent_config import AgentConfig
+from vectara_agentic.tools import ToolsFactory
+from vectara_agentic.types import ModelProvider
+
+import nest_asyncio
+nest_asyncio.apply()
+
+def mult(x: float, y: float) -> float:
+    "Multiply two numbers"
+    return x * y
+
+
+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_multiturn(self):
+        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")
+
+
+if __name__ == "__main__":
+    unittest.main()

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

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

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

@@ -1126,9 +1126,14 @@ class Agent:
         return json.dumps(self.to_dict())
 
     @classmethod
-    def loads(cls, data: str) -> "Agent":
+    def loads(
+        cls,
+        data: str,
+        agent_progress_callback: Optional[Callable[[AgentStatusType, str], None]] = None,
+        query_logging_callback: Optional[Callable[[str, str], None]] = None
+    ) -> "Agent":
         """Create an Agent instance from a JSON string."""
-        return cls.from_dict(json.loads(data))
+        return cls.from_dict(json.loads(data), agent_progress_callback, query_logging_callback)
 
     def to_dict(self) -> Dict[str, Any]:
         """Serialize the Agent instance to a dictionary."""
@@ -1185,7 +1190,12 @@ class Agent:
         }
 
     @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> "Agent":
+    def from_dict(
+        cls,
+        data: Dict[str, Any],
+        agent_progress_callback: Optional[Callable] = None,
+        query_logging_callback: Optional[Callable] = None
+    ) -> "Agent":
         """Create an Agent instance from a dictionary."""
         agent_config = AgentConfig.from_dict(data["agent_config"])
         fallback_agent_config = (
@@ -1286,6 +1296,8 @@ class Agent:
             verbose=data["verbose"],
             fallback_agent_config=fallback_agent_config,
             workflow_cls=data["workflow_cls"],
+            agent_progress_callback=agent_progress_callback,
+            query_logging_callback=query_logging_callback,
         )
         memory = (
             pickle.loads(data["memory"].encode("latin-1"))
@@ -1294,4 +1306,5 @@ class Agent:
         )
         if memory:
             agent.agent.memory = memory
+            agent.memory = memory
         return agent

{vectara_agentic-0.2.21 → vectara_agentic-0.2.22}/vectara_agentic/llm_utils.py

@@ -11,18 +11,54 @@ from llama_index.core.llms import LLM
 from llama_index.llms.openai import OpenAI
 from llama_index.llms.anthropic import Anthropic
 
+# Optional provider imports with graceful fallback
+try:
+    from llama_index.llms.google_genai import GoogleGenAI
+except ImportError:
+    GoogleGenAI = None
+
+try:
+    from llama_index.llms.together import TogetherLLM
+except ImportError:
+    TogetherLLM = None
+
+try:
+    from llama_index.llms.groq import Groq
+except ImportError:
+    Groq = None
+
+try:
+    from llama_index.llms.fireworks import Fireworks
+except ImportError:
+    Fireworks = None
+
+try:
+    from llama_index.llms.bedrock_converse import BedrockConverse
+except ImportError:
+    BedrockConverse = None
+
+try:
+    from llama_index.llms.cohere import Cohere
+except ImportError:
+    Cohere = None
+
+try:
+    from llama_index.llms.openai_like import OpenAILike
+except ImportError:
+    OpenAILike = None
+
 from .types import LLMRole, AgentType, ModelProvider
 from .agent_config import AgentConfig
 
 provider_to_default_model_name = {
     ModelProvider.OPENAI: "gpt-4.1",
     ModelProvider.ANTHROPIC: "claude-sonnet-4-20250514",
-    ModelProvider.TOGETHER: "Qwen/Qwen2.5-72B-Instruct-Turbo",
+    ModelProvider.TOGETHER: "meta-llama/Llama-4-Scout-17B-16E-Instruct",
     ModelProvider.GROQ: "deepseek-r1-distill-llama-70b",
     ModelProvider.FIREWORKS: "accounts/fireworks/models/firefunction-v2",
     ModelProvider.BEDROCK: "us.anthropic.claude-sonnet-4-20250514-v1:0",
     ModelProvider.COHERE: "command-a-03-2025",
-    ModelProvider.GEMINI: "models/gemini-2.0-flash",
+    ModelProvider.GEMINI: "models/gemini-2.5-flash",
 }
 
 DEFAULT_MODEL_PROVIDER = ModelProvider.OPENAI
@@ -106,8 +142,8 @@ def get_llm(role: LLMRole, config: Optional[AgentConfig] = None) -> LLM:
             max_tokens=max_tokens,
         )
     elif model_provider == ModelProvider.GEMINI:
-        from llama_index.llms.google_genai import GoogleGenAI
-
+        if GoogleGenAI is None:
+            raise ImportError("google_genai not available. Install with: pip install llama-index-llms-google-genai")
         llm = GoogleGenAI(
             model=model_name,
             temperature=0,
@@ -116,8 +152,8 @@ def get_llm(role: LLMRole, config: Optional[AgentConfig] = None) -> LLM:
             max_tokens=max_tokens,
         )
     elif model_provider == ModelProvider.TOGETHER:
-        from llama_index.llms.together import TogetherLLM
-
+        if TogetherLLM is None:
+            raise ImportError("together not available. Install with: pip install llama-index-llms-together")
         llm = TogetherLLM(
             model=model_name,
             temperature=0,
@@ -125,8 +161,8 @@ def get_llm(role: LLMRole, config: Optional[AgentConfig] = None) -> LLM:
             max_tokens=max_tokens,
         )
     elif model_provider == ModelProvider.GROQ:
-        from llama_index.llms.groq import Groq
-
+        if Groq is None:
+            raise ImportError("groq not available. Install with: pip install llama-index-llms-groq")
         llm = Groq(
             model=model_name,
             temperature=0,
@@ -134,12 +170,12 @@ def get_llm(role: LLMRole, config: Optional[AgentConfig] = None) -> LLM:
             max_tokens=max_tokens,
         )
     elif model_provider == ModelProvider.FIREWORKS:
-        from llama_index.llms.fireworks import Fireworks
-
+        if Fireworks is None:
+            raise ImportError("fireworks not available. Install with: pip install llama-index-llms-fireworks")
         llm = Fireworks(model=model_name, temperature=0, max_tokens=max_tokens)
     elif model_provider == ModelProvider.BEDROCK:
-        from llama_index.llms.bedrock_converse import BedrockConverse
-
+        if BedrockConverse is None:
+            raise ImportError("bedrock_converse not available. Install with: pip install llama-index-llms-bedrock")
         aws_profile_name = os.getenv("AWS_PROFILE", None)
         aws_region = os.getenv("AWS_REGION", "us-east-2")
 
@@ -151,12 +187,12 @@ def get_llm(role: LLMRole, config: Optional[AgentConfig] = None) -> LLM:
             region_name=aws_region,
         )
     elif model_provider == ModelProvider.COHERE:
-        from llama_index.llms.cohere import Cohere
-
+        if Cohere is None:
+            raise ImportError("cohere not available. Install with: pip install llama-index-llms-cohere")
         llm = Cohere(model=model_name, temperature=0, max_tokens=max_tokens)
     elif model_provider == ModelProvider.PRIVATE:
-        from llama_index.llms.openai_like import OpenAILike
-
+        if OpenAILike is None:
+            raise ImportError("openai_like not available. Install with: pip install llama-index-llms-openai-like")
         llm = OpenAILike(
             model=model_name,
             temperature=0,

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vectara_agentic
-Version: 0.2.21
+Version: 0.2.22
 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

vectara_agentic-0.2.21/tests/test_groq.py

@@ -1,115 +0,0 @@
-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
-
-
-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.assertTrue(
-            any(sub in str(res) for sub in ["I don't know", "I do not have", "please specify which company"])
-        )
-
-
-if __name__ == "__main__":
-    unittest.main()