enh: Always use the chat method

.github/workflows/integration_test.yml

@@ -28,7 +28,7 @@ jobs:
       matrix:
         php-versions: [ '8.1' ]
         databases: [ 'sqlite' ]
-        server-versions: [ 'master', 'stable30' ]
+        server-versions: [ 'master', 'stable31', 'stable30' ]
 
     name: Integration test on ☁️${{ matrix.server-versions }} 🐘${{ matrix.php-versions }}
 
@@ -95,14 +95,6 @@ jobs:
           filename: ${{ env.APP_NAME }}/appinfo/info.xml
           expression: "/info/version/text()"
 
-      - name: Checkout AppAPI
-        uses: actions/checkout@v4
-        if: ${{ matrix.server-versions == 'stable30' }}
-        with:
-          repository: cloud-py-api/app_api
-          path: apps/app_api
-          ref: v3.2.1
-
       - name: Set up Nextcloud
         if: ${{ matrix.databases != 'pgsql'}}
         run: |
@@ -141,7 +133,7 @@ jobs:
         env:
           APP_VERSION: ${{ fromJson(steps.appinfo.outputs.result).version }}
         run: |
-          poetry run python3 main.py > backend_logs &
+          poetry run python3 main.py > ../backend_logs 2>&1 &
 
       - name: Register backend
         run: |
@@ -159,7 +151,7 @@ jobs:
           TASK_ID=$(echo $TASK | jq '.ocs.data.task.id')
           NEXT_WAIT_TIME=0
           TASK_STATUS='"STATUS_SCHEDULED"'
-          until [ $NEXT_WAIT_TIME -eq 25 ] || [ "$TASK_STATUS" == '"STATUS_SUCCESSFUL"' ] || [ "$TASK_STATUS" == '"STATUS_FAILED"' ]; do
+          until [ $NEXT_WAIT_TIME -eq 35 ] || [ "$TASK_STATUS" == '"STATUS_SUCCESSFUL"' ] || [ "$TASK_STATUS" == '"STATUS_FAILED"' ]; do
             TASK=$(curl -u "$CREDS" -H "oCS-APIRequest: true" http://localhost:8080/ocs/v2.php/taskprocessing/task/$TASK_ID?format=json)
             echo $TASK
             TASK_STATUS=$(echo $TASK | jq '.ocs.data.task.status')

default_config/config.json

@@ -55,6 +55,33 @@
             "n_ctx": 8224,
             "max_tokens": 8196,
             "stop": ["<|eot_id|>"],
+            "temperature": 0.15
+        }
+    },
+    "olmo-2-1124-7B-instruct-Q4_K_M": {
+        "prompt": "<|endoftext|><|system|>\n{system_prompt}\n<|user|>\n{system_prompt}\n{user_prompt}\n<|assistant|>\n",
+        "loader_config": {
+            "n_ctx": 4096,
+            "max_tokens": 2048,
+            "stop": ["<|endoftext|>"],
+            "temperature": 0.7
+        }
+    },
+    "olmo-2-1124-13B-instruct-Q5_K_M": {
+        "prompt": "<|endoftext|><|system|>\n{system_prompt}\n<|user|>\n{system_prompt}\n{user_prompt}\n<|assistant|>\n",
+        "loader_config": {
+            "n_ctx": 4096,
+            "max_tokens": 2048,
+            "stop": ["<|endoftext|>"],
+            "temperature": 0.7
+        }
+    },
+    "Mistral-Small-24B-Instruct-2501-Q3_K_M": {
+        "prompt": "<|endoftext|><|system|>\n{system_prompt}\n<|user|>\n{system_prompt}\n{user_prompt}\n<|assistant|>\n",
+        "loader_config": {
+            "n_ctx": 32768,
+            "max_tokens": 2048,
+            "stop": ["<|endoftext|>"],
             "temperature": 0.3
         }
     },

lib/change_tone.py

@@ -7,14 +7,15 @@
 
 from langchain.prompts import PromptTemplate
 from langchain.schema.prompt_template import BasePromptTemplate
+from langchain_core.messages import SystemMessage, HumanMessage
 from langchain_core.runnables import Runnable
 
-class ChangeToneProcessor():
+class ChangeToneProcessor:
 
     runnable: Runnable
 
     """
-    A topics chain
+    A change tone processor
     """
     system_prompt: str = "You're an AI assistant tasked with rewriting the text given to you by the user in another tone."
     user_prompt: BasePromptTemplate = PromptTemplate(
@@ -32,8 +33,10 @@ class ChangeToneProcessor():
     def __init__(self, runnable: Runnable):
         self.runnable = runnable
 
-
-    def __call__(self, inputs: dict[str,Any],
-        ) -> dict[str, Any]:
-            output = self.runnable.invoke({"user_prompt": self.user_prompt.format_prompt(text=inputs['input'], tone=inputs['tone']), "system_prompt": self.system_prompt})
-            return {'output': output}
+    def __call__(self, input_data: dict) -> dict[str, Any]:
+        """Process a single input"""
+        messages = [
+            SystemMessage(content=self.system_prompt),
+            HumanMessage(content=self.user_prompt.format_prompt(text=input_data['input'], tone=input_data['tone']).to_string())
+        ]
+        return {'output':self.runnable.invoke(messages).content }

lib/chatwithtools.py

@@ -11,8 +11,6 @@
 from langchain_core.messages import SystemMessage, HumanMessage, ToolMessage
 from langchain_core.messages.ai import AIMessage
 
-
-
 def try_parse_tool_calls(content: str):
     """Try parse the tool calls."""
     tool_calls = []
@@ -43,42 +41,49 @@ def try_parse_tool_calls(content: str):
 
 class ChatWithToolsProcessor:
     """
-    A chat with tools processor
-    """
+	A chat with tools processor that supports batch processing
+	"""
 
     model: ChatLlamaCpp
 
     def __init__(self, runner: ChatLlamaCpp):
         self.model = runner
 
-    def __call__(
-            self,
-            inputs: dict[str, Any],
-    ) -> dict[str, str]:
-        model_with_tools = self.model.bind_tools(json.loads(inputs['tools']))
+    def _process_single_input(self, input_data: dict[str, Any]) -> dict[str, Any]:
+        model_with_tools = self.model.bind_tools(json.loads(input_data['tools']))
 
         messages = []
-        messages.append(SystemMessage(content=inputs['system_prompt']))
-        for raw_message in inputs['history']:
+        messages.append(SystemMessage(content=input_data['system_prompt']))
+
+        for raw_message in input_data['history']:
             message = json.loads(raw_message)
             if message['role'] == 'assistant':
-                messages.append(AIMessage(content=inputs['system_prompt']))
+                messages.append(AIMessage(content=input_data['system_prompt']))
             elif message['role'] == 'human':
-                messages.append(HumanMessage(content=inputs['system_prompt']))
+                messages.append(HumanMessage(content=input_data['system_prompt']))
 
-        messages.append(HumanMessage(content=inputs['input']))
+        messages.append(HumanMessage(content=input_data['input']))
 
         try:
-            tool_messages = json.loads(inputs['tool_message'])
+            tool_messages = json.loads(input_data['tool_message'])
             for tool_message in tool_messages:
-                messages.append(ToolMessage(content=tool_message['content'], name=tool_message['name'], tool_call_id='42'))
+                messages.append(ToolMessage(
+                    content=tool_message['content'],
+                    name=tool_message['name'],
+                    tool_call_id='42'
+                ))
         except:
             pass
 
-        response = model_with_tools.invoke(
-            messages
-        )
-        print(response.content)
+        response = model_with_tools.invoke(messages)
+
         if not response.tool_calls or len(response.tool_calls) == 0:
             response = AIMessage(**try_parse_tool_calls(response.content))
-        return {'output': response.content, 'tool_calls': json.dumps(response.tool_calls)}
+
+        return {
+            'output': response.content,
+            'tool_calls': json.dumps(response.tool_calls)
+        }
+
+    def __call__(self, inputs: dict[str, Any]) -> dict[str, Any]:
+        return self._process_single_input(inputs)

lib/contextwrite.py

@@ -1,25 +1,23 @@
 # SPDX-FileCopyrightText: 2024 Nextcloud GmbH and Nextcloud contributors
 # SPDX-License-Identifier: AGPL-3.0-or-later
-"""A langchain chain to formalize text
+"""A chain that changes the tone of a text
 """
 
-from typing import Any, Optional
+from typing import Any
 
-from langchain.base_language import BaseLanguageModel
-from langchain.callbacks.manager import CallbackManagerForChainRun
-from langchain.chains.base import Chain
 from langchain.prompts import PromptTemplate
 from langchain.schema.prompt_template import BasePromptTemplate
-from langchain.text_splitter import CharacterTextSplitter
-from langchain.chains import LLMChain
+from langchain_core.messages import SystemMessage, HumanMessage
+from langchain_core.runnables import Runnable
+
+class ContextWriteProcessor:
+
+    runnable: Runnable
 
-class ContextWriteChain(Chain):
     """
-    A reformulation chain
+    A context write processor
     """
-
-    system_prompt = "You're an AI assistant tasked with reformulating the text given to you by the user."
-
+    system_prompt: str = "You're an AI assistant tasked with reformulating the text given to you by the user."
     user_prompt: BasePromptTemplate = PromptTemplate(
         input_variables=["style_input", "source_input"],
         template="""
@@ -36,49 +34,16 @@ class ContextWriteChain(Chain):
 Only output the newly written text without quotes, nothing else, no introductory or explanatory text.
         """
     )
-    # Multilingual output doesn't work with llama3.1
-    # Task doesn't work with llama 3.1
-
-
-    """Prompt object to use."""
-    llm_chain: LLMChain
-    output_key: str = "text"  #: :meta private:
-
-    class Config:
-        """Configuration for this pydantic object."""
-
-        extra = 'forbid'
-        arbitrary_types_allowed = True
-
-    @property
-    def input_keys(self) -> list[str]:
-        """Will be whatever keys the prompt expects.
-
-        :meta private:
-        """
-        return ['style_input', 'source_input']
-
-    @property
-    def output_keys(self) -> list[str]:
-        """Will always return text key.
-
-        :meta private:
-        """
-        return [self.output_key]
-
-    def _call(
-            self,
-            inputs: dict[str, Any],
-            run_manager: Optional[CallbackManagerForChainRun] = None,
-    ) -> dict[str, str]:
-
-        if not {"user_prompt", "system_prompt"} == set(self.llm_chain.input_keys):
-            raise ValueError("llm_chain must have input_keys ['user_prompt', 'system_prompt']")
-        if not self.llm_chain.output_keys == [self.output_key]:
-            raise ValueError(f"llm_chain must have output_keys [{self.output_key}]")
-
-        return self.llm_chain.invoke({"user_prompt": self.user_prompt.format_prompt(style_input=inputs['style_input'], source_input=inputs['source_input']), "system_prompt": self.system_prompt})
-
-    @property
-    def _chain_type(self) -> str:
-        return "simplify_chain"
+    def __init__(self, runnable: Runnable):
+        self.runnable = runnable
+
+    def __call__(self, inputs: dict[str, Any]) -> dict[str, Any]:
+        messages = [
+            SystemMessage(content=self.system_prompt),
+            HumanMessage(content=self.user_prompt.format(
+                style_input=inputs['style_input'],
+                source_input=inputs['source_input']
+            ))
+        ]
+        output = self.runnable.invoke(messages)
+        return {'output': output.content}