hana-ai 1.0.25053000__tar.gz → 1.0.25061700__tar.gz

{hana_ai-1.0.25053000 → hana_ai-1.0.25061700}/INTRODUCTION.md

@@ -43,6 +43,7 @@ Provided AI-tools for streamlining usage of HANA ML functions in context of the
 | forecast_line_plot | To generate line plot for the forecasted result. |
 | intermittent_forecast | To forecast the intermittent time series data. |
 | list_models | To list the models in the model storage. |
+| delete_models | To delete the model from the model storage. |
 | seasonality_test | To check the seasonality of the time series data. |
 | stationarity_test | To check the stationarity of the time series data. |
 | trend_test | To check the trend of the time series data. |

{hana_ai-1.0.25053000/src/hana_ai.egg-info → hana_ai-1.0.25061700}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hana_ai
-Version: 1.0.25053000
+Version: 1.0.25061700
 Summary: Generative AI Toolkit for SAP HANA Cloud
 Author: SAP
 License: Apache-2.0

{hana_ai-1.0.25053000 → hana_ai-1.0.25061700}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "hana_ai"
-version = "1.0.25053000"
+version = "1.0.25061700"
 authors = [
     {name = "SAP"}
 ]

{hana_ai-1.0.25053000 → hana_ai-1.0.25061700}/src/hana_ai/__init__.py

@@ -2,4 +2,4 @@
 hana_ai is a Python package for AI/ML related utilities.
 """
 
-__version__ = "1.0.25053000"
+__version__ = "1.0.25061700"

{hana_ai-1.0.25053000 → hana_ai-1.0.25061700}/src/hana_ai/agents/hanaml_agent_with_memory.py

@@ -13,7 +13,7 @@ import inspect
 import logging
 import pandas as pd
 from pydantic import ValidationError
-from langchain.agents import initialize_agent, AgentType
+from langchain.agents import initialize_agent, AgentType, Tool
 from langchain.callbacks.base import BaseCallbackHandler
 from langchain_core.chat_history import InMemoryChatMessageHistory
 from langchain_core.messages.base import BaseMessage
@@ -86,6 +86,8 @@ class _ToolObservationCallbackHandler(BaseCallbackHandler):
         self.max_observations = max_observations  # Set your desired limit here
 
     def on_tool_end(self, output: str, **kwargs):
+        if kwargs.get("name") == "delete_chat_history":
+            return  # 跳过记录
         memory = self.memory_getter()
         # Get all current observations in chronological order
         current_obs = [msg for msg in memory.messages if self._is_observation(msg)]
@@ -154,10 +156,21 @@ class HANAMLAgentWithMemory(object):
     """
     def __init__(self, llm, tools, session_id="hanaai_chat_session", n_messages=10, max_observations=5, verbose=False, **kwargs):
         self.llm = llm
-        self.tools = tools
+        self.tools = list(tools)
         self.memory = InMemoryChatMessageHistory(session_id=session_id)
         system_prompt = CHATBOT_SYSTEM_PROMPT
-
+        # Add the delete_chat_history tool
+        delete_tool = Tool(
+            name="delete_chat_history",
+            func=self.delete_chat_history_tool,
+            description=(
+                "Use this tool ONLY when the user explicitly requests to delete ALL chat history. "
+                "This action cannot be undone. Do NOT call this tool for any other reason. "
+                "Input must ALWAYS be an empty string (''). Example usage: delete_chat_history('')"
+            ),
+            return_direct=True
+        )
+        self.tools.append(delete_tool)
         self.prompt = ChatPromptTemplate.from_messages([
             ("system", system_prompt),
             MessagesPlaceholder(variable_name="history", n_messages=n_messages),
@@ -167,7 +180,7 @@ class HANAMLAgentWithMemory(object):
         self.verbose = verbose
         # Create callback handler linked to memory
         self.observation_callback = _ToolObservationCallbackHandler(lambda: self.memory, max_observations=max_observations)
-        chain: Runnable = self.prompt | initialize_agent(tools,
+        chain: Runnable = self.prompt | initialize_agent(self.tools,
                                                     llm,
                                                     agent=AgentType.STRUCTURED_CHAT_ZERO_SHOT_REACT_DESCRIPTION,verbose=verbose,
                                                     callbacks=[self.observation_callback],
@@ -215,6 +228,20 @@ class HANAMLAgentWithMemory(object):
                                                                   input_messages_key="question",
                                                                   history_messages_key="history")
 
+    def delete_chat_history_tool(self, _input=""):
+        """
+        Delete chat history tool.
+        """
+        # 清除内存中的聊天记录
+        self.memory.clear()
+        # 重置回调处理器
+        self.observation_callback = _ToolObservationCallbackHandler(
+            lambda: self.memory,
+            self.observation_callback.max_observations
+        )
+        return "Chat history has been deleted successfully."
+
+
     def run(self, question):
         """
         Chat with the chatbot.
@@ -254,8 +281,14 @@ class HANAMLAgentWithMemory(object):
                     error_message = str(e)
                     if "Error code: 429" not in error_message:
                         self.memory.add_ai_message(f"The error message is `{error_message}`. The response is `{response}`.")
+            if "action" in response and "action_input" in response:
+                try:
+                    response = json.loads(response)
+                except:
+                    pass
             if isinstance(response, str) and response.strip() == "":
                 response = "I'm sorry, I don't understand. Please ask me again."
+
         if isinstance(response, dict) and 'action' in response and 'action_input' in response:
             action = response.get("action")
             for tool in self.tools:
@@ -308,7 +341,7 @@ def stateless_call(llm, tools, question, chat_history=None, verbose=False, retur
         MessagesPlaceholder(variable_name="history", messages=chat_history),
         ("human", "{question}"),
     ])
-    agent: Runnable = prompt | initialize_agent(tools, llm, agent=AgentType.STRUCTURED_CHAT_ZERO_SHOT_REACT_DESCRIPTION, verbose=verbose, return_intermediate_steps=return_intermediate_steps, handle_parsing_errors=True)
+    agent: Runnable = prompt | initialize_agent(tools, llm, agent=AgentType.STRUCTURED_CHAT_ZERO_SHOT_REACT_DESCRIPTION, verbose=verbose, return_intermediate_steps=return_intermediate_steps)
     intermediate_steps = None
     try:
         response = agent.invoke({"question": question, "history": chat_history})
@@ -342,6 +375,11 @@ def stateless_call(llm, tools, question, chat_history=None, verbose=False, retur
             except Exception as e:
                 error_message = str(e)
                 response = f"The error message is `{error_message}`. Please display the error message, and then analyze the error message and provide the solution."
+        if "action" in response and "action_input" in response:
+            try:
+                response = json.loads(response)
+            except:
+                pass
         if isinstance(response, str) and response.strip() == "":
             response = "I'm sorry, I don't understand. Please ask me again."
     if isinstance(response, dict) and 'action' in response and 'action_input' in response:

{hana_ai-1.0.25053000 → hana_ai-1.0.25061700}/src/hana_ai/tools/code_template_tools.py

@@ -9,13 +9,9 @@ The following class are available:
 """
 # pylint: disable=unused-argument
 
-from typing import Optional, Type
+from typing import Type
 from pydantic import BaseModel
 from langchain.tools import BaseTool
-from langchain.callbacks.manager import (
-    AsyncCallbackManagerForToolRun,
-    CallbackManagerForToolRun,
-)
 
 from hana_ai.vectorstore.hana_vector_engine import HANAMLinVectorEngine
 
@@ -55,9 +51,17 @@ class GetCodeTemplateFromVectorDB(BaseTool):
         self.vectordb = vectordb
 
     def _run(
-        self, query: str, run_manager: Optional[CallbackManagerForToolRun] = None
+        self,
+        **kwargs
     ) -> str:
         """Use the tool."""
+
+        if "kwargs" in kwargs:
+            kwargs = kwargs["kwargs"]
+        query = kwargs.get("query", None)
+        if query is None:
+            return "Query is required"
+
         if self.vectordb is None:
             raise ValueError("No vector database set.")
         model = self.vectordb
@@ -66,7 +70,7 @@ class GetCodeTemplateFromVectorDB(BaseTool):
         return result
 
     async def _arun(
-        self, query: str, run_manager: Optional[AsyncCallbackManagerForToolRun] = None
+        self, **kwargs
     ) -> str:
         """Use the tool asynchronously."""
-        raise NotImplementedError("Does not support async")
+        return self._run(**kwargs)

{hana_ai-1.0.25053000 → hana_ai-1.0.25061700}/src/hana_ai/tools/hana_ml_tools/additive_model_forecast_tools.py

@@ -12,11 +12,6 @@ import json
 import logging
 from typing import Optional, Type, Union
 from pydantic import BaseModel, Field
-
-from langchain.callbacks.manager import (
-    AsyncCallbackManagerForToolRun,
-    CallbackManagerForToolRun,
-)
 from langchain_core.tools import BaseTool
 
 from hana_ml import ConnectionContext
@@ -29,7 +24,7 @@ logger = logging.getLogger(__name__)
 
 def _guess_fourier_order(period: int) -> int:
     # Calculate base value and round to nearest integer
-    base_value = round(period / 36.5)
+    base_value = round(float(period) / 36.5)
 
     # Apply bounds: minimum 3, maximum 10
     return max(3, min(10, base_value))
@@ -163,31 +158,41 @@ class AdditiveModelForecastFitAndSave(BaseTool):
 
     def _run(
         self,
-        fit_table: str,
-        key: str,
-        name: str,
-        version: Optional[str] = None,
-        growth: Optional[str] = None,
-        logistic_growth_capacity: Optional[float] = None,
-        seasonality_mode: Optional[str] = None,
-        period: Union[Optional[int], Optional[list]] = None,
-        num_changepoints: Optional[int] = None,
-        changepoint_range: Optional[float] = None,
-        regressor: Optional[list] = None,
-        changepoints: Optional[list] = None,
-        yearly_seasonality: Optional[str] = None,
-        weekly_seasonality: Optional[str] = None,
-        daily_seasonality: Optional[str] = None,
-        seasonality_prior_scale: Optional[float] = None,
-        holiday_prior_scale: Optional[float] = None,
-        changepoint_prior_scale: Optional[float] = None,
-        endog: Optional[str] = None,
-        exog: Union[Optional[str], Optional[list]] = None,
-        holiday_table: Optional[str] = None,
-        categorical_variable: Union[Optional[str], Optional[list]] = None,
-        run_manager: Optional[CallbackManagerForToolRun] = None
+        **kwargs
     ) -> str:
         """Use the tool."""
+
+        if "kwargs" in kwargs:
+            kwargs = kwargs["kwargs"]
+        fit_table = kwargs.get("fit_table", None)
+        if fit_table is None:
+            return "Training table is required"
+        key = kwargs.get("key", None)
+        if key is None:
+            return "key is required"
+        name = kwargs.get("name", None)
+        if name is None:
+            return "Model name is required"
+        version = kwargs.get("version", None)
+        growth = kwargs.get("growth", None)
+        logistic_growth_capacity = kwargs.get("logistic_growth_capacity", None)
+        seasonality_mode = kwargs.get("seasonality_mode", None)
+        period = kwargs.get("period", None)
+        num_changepoints = kwargs.get("num_changepoints", None)
+        changepoint_range = kwargs.get("changepoint_range", None)
+        regressor = kwargs.get("regressor", None)
+        changepoints = kwargs.get("changepoints", None)
+        yearly_seasonality = kwargs.get("yearly_seasonality", None)
+        weekly_seasonality = kwargs.get("weekly_seasonality", None)
+        daily_seasonality = kwargs.get("daily_seasonality", None)
+        seasonality_prior_scale = kwargs.get("seasonality_prior_scale", None)
+        holiday_prior_scale = kwargs.get("holiday_prior_scale", None)
+        changepoint_prior_scale = kwargs.get("changepoint_prior_scale", None)
+        endog = kwargs.get("endog", None)
+        exog = kwargs.get("exog", None)
+        holiday_table = kwargs.get("holiday_table", None)
+        categorical_variable = kwargs.get("categorical_variable", None)
+
         # check fit_table exists
         if not self.connection_context.has_table(fit_table):
             return f"Table {fit_table} does not exist in the database."
@@ -256,54 +261,9 @@ class AdditiveModelForecastFitAndSave(BaseTool):
 
     async def _arun(
         self,
-        fit_table: str,
-        key: str,
-        name: str,
-        version: Optional[str] = None,
-        growth: Optional[str] = None,
-        logistic_growth_capacity: Optional[float] = None,
-        seasonality_mode: Optional[str] = None,
-        period: Union[Optional[int], Optional[list]] = None,
-        num_changepoints: Optional[int] = None,
-        changepoint_range: Optional[float] = None,
-        regressor: Optional[list] = None,
-        changepoints: Optional[list] = None,
-        yearly_seasonality: Optional[str] = None,
-        weekly_seasonality: Optional[str] = None,
-        daily_seasonality: Optional[str] = None,
-        seasonality_prior_scale: Optional[float] = None,
-        holiday_prior_scale: Optional[float] = None,
-        changepoint_prior_scale: Optional[float] = None,
-        endog: Optional[str] = None,
-        exog: Union[Optional[str], Optional[list]] = None,
-        holiday_table: Optional[str] = None,
-        categorical_variable: Union[Optional[str], Optional[list]] = None,
-        run_manager: Optional[AsyncCallbackManagerForToolRun] = None
+        **kwargs
     ) -> str:
-        return self._run(
-            fit_table=fit_table,
-            key=key,
-            name=name,
-            version=version,
-            growth=growth,
-            logistic_growth_capacity=logistic_growth_capacity,
-            seasonality_mode=seasonality_mode,
-            period=period,
-            num_changepoints=num_changepoints,
-            changepoint_range=changepoint_range,
-            regressor=regressor,
-            changepoints=changepoints,
-            yearly_seasonality=yearly_seasonality,
-            weekly_seasonality=weekly_seasonality,
-            daily_seasonality=daily_seasonality,
-            seasonality_prior_scale=seasonality_prior_scale,
-            holiday_prior_scale=holiday_prior_scale,
-            changepoint_prior_scale=changepoint_prior_scale,
-            endog=endog,
-            exog=exog,
-            holiday_table=holiday_table,
-            categorical_variable=categorical_variable,
-            run_manager=run_manager
+        return self._run(**kwargs
         )
 
 class AdditiveModelForecastLoadModelAndPredict(BaseTool):
@@ -374,21 +334,31 @@ class AdditiveModelForecastLoadModelAndPredict(BaseTool):
 
     def _run(
         self,
-        predict_table: str,
-        key: str,
-        name: str,
-        version: Optional[str] = None,
-        exog: Union[Optional[str], Optional[list]] = None,
-        logistic_growth_capacity: Optional[float] = None,
-        interval_width: Optional[float] = None,
-        uncertainty_samples: Optional[int] = None,
-        show_explainer: Optional[bool] = None,
-        decompose_seasonality: Optional[bool] = None,
-        decompose_holiday: Optional[bool] = None,
-        add_placeholder: Optional[bool] = True,
-        run_manager: Optional[CallbackManagerForToolRun] = None
+        **kwargs
     ) -> str:
         """Use the tool."""
+
+        if "kwargs" in kwargs:
+            kwargs = kwargs["kwargs"]
+        predict_table = kwargs.get("predict_table", None)
+        if predict_table is None:
+            return "Prediction table is required"
+        key = kwargs.get("key", None)
+        if key is None:
+            return "Key is required"
+        name = kwargs.get("name", None)
+        if name is None:
+            return "Model name is required"
+        version = kwargs.get("version", None)
+        exog = kwargs.get("exog", None)
+        logistic_growth_capacity = kwargs.get("logistic_growth_capacity", None)
+        interval_width = kwargs.get("interval_width", None)
+        uncertainty_samples = kwargs.get("uncertainty_samples", None)
+        show_explainer = kwargs.get("show_explainer", None)
+        decompose_seasonality = kwargs.get("decompose_seasonality", None)
+        decompose_holiday = kwargs.get("decompose_holiday", None)
+        add_placeholder = kwargs.get("add_placeholder", True)
+
         predict_df = self.connection_context.table(predict_table)
         if not self.connection_context.has_table(predict_table):
             return f"Table {predict_table} does not exist in the database."
@@ -403,15 +373,15 @@ class AdditiveModelForecastLoadModelAndPredict(BaseTool):
             predict_df = predict_df.add_constant("PLACEHOLDER", 0)
         try:
             model.predict(data=predict_df,
-                        key=key,
-                        exog=exog,
-                        logistic_growth_capacity=logistic_growth_capacity,
-                        interval_width=interval_width,
-                        uncertainty_samples=uncertainty_samples,
-                        show_explainer=show_explainer,
-                        decompose_seasonality=decompose_seasonality,
-                        decompose_holiday=decompose_holiday,
-                        add_placeholder=add_placeholder)
+                          key=key,
+                          exog=exog,
+                          logistic_growth_capacity=logistic_growth_capacity,
+                          interval_width=interval_width,
+                          uncertainty_samples=uncertainty_samples,
+                          show_explainer=show_explainer,
+                          decompose_seasonality=decompose_seasonality,
+                          decompose_holiday=decompose_holiday,
+                          add_placeholder=add_placeholder)
         except ValueError as ve:
             # Handles invalid parameter values (e.g., alpha not in [0,1])
             return f"ValueError occurred: {str(ve)}"
@@ -437,32 +407,8 @@ class AdditiveModelForecastLoadModelAndPredict(BaseTool):
 
     async def _arun(
         self,
-        predict_table: str,
-        key: str,
-        name: str,
-        version: Optional[str] = None,
-        exog: Union[Optional[str], Optional[list]] = None,
-        logistic_growth_capacity: Optional[float] = None,
-        interval_width: Optional[float] = None,
-        uncertainty_samples: Optional[int] = None,
-        show_explainer: Optional[bool] = None,
-        decompose_seasonality: Optional[bool] = None,
-        decompose_holiday: Optional[bool] = None,
-        add_placeholder: Optional[bool] = True,
-        run_manager: Optional[AsyncCallbackManagerForToolRun] = None
+        **kwargs
     ) -> str:
         return self._run(
-            predict_table=predict_table,
-            key=key,
-            name=name,
-            version=version,
-            exog=exog,
-            logistic_growth_capacity=logistic_growth_capacity,
-            interval_width=interval_width,
-            uncertainty_samples=uncertainty_samples,
-            show_explainer=show_explainer,
-            decompose_seasonality=decompose_seasonality,
-            decompose_holiday=decompose_holiday,
-            add_placeholder=add_placeholder,
-            run_manager=run_manager
+            **kwargs
         )