miscai 0.1.0__tar.gz

miscai-0.1.0/.gitignore

@@ -0,0 +1,2 @@
+.venv
+dist

miscai-0.1.0/LICENSE

@@ -0,0 +1,25 @@
+The MIT License (MIT)
+=====================
+
+Copyright © '2026' 'Daniel (pui4)'
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the “Software”), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

miscai-0.1.0/PKG-INFO

@@ -0,0 +1,193 @@
+Metadata-Version: 2.4
+Name: miscai
+Version: 0.1.0
+Summary: Miscellaneous differnet AI tools for embedding into projects.
+License: The MIT License (MIT)
+        =====================
+        
+        Copyright © '2026' 'Daniel (pui4)'
+        
+        Permission is hereby granted, free of charge, to any person
+        obtaining a copy of this software and associated documentation
+        files (the “Software”), to deal in the Software without
+        restriction, including without limitation the rights to use,
+        copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the
+        Software is furnished to do so, subject to the following
+        conditions:
+        
+        The above copyright notice and this permission notice shall be
+        included in all copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND,
+        EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+        OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+        NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+        HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+        WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+        FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+        OTHER DEALINGS IN THE SOFTWARE.
+License-File: LICENSE
+Requires-Python: >=3.14
+Provides-Extra: dlm
+Requires-Dist: chromadb>=1.5.2; extra == 'dlm'
+Requires-Dist: peft>=0.19.1; extra == 'dlm'
+Requires-Dist: requests>=2.34.2; extra == 'dlm'
+Requires-Dist: torch>=2.10.0; extra == 'dlm'
+Requires-Dist: transformers>=4.57.3; extra == 'dlm'
+Provides-Extra: llm
+Requires-Dist: chromadb>=1.5.2; extra == 'llm'
+Requires-Dist: ollama>=0.6.1; extra == 'llm'
+Requires-Dist: peft>=0.19.1; extra == 'llm'
+Requires-Dist: torch>=2.10.0; extra == 'llm'
+Requires-Dist: transformers>=4.57.3; extra == 'llm'
+Provides-Extra: stt
+Requires-Dist: numpy>=2.4.6; extra == 'stt'
+Requires-Dist: pywhispercpp>=1.4.1; extra == 'stt'
+Provides-Extra: tts
+Requires-Dist: numpy>=2.4.6; extra == 'tts'
+Requires-Dist: pocket-tts>=1.1.1; extra == 'tts'
+Requires-Dist: scipy>=1.17.1; extra == 'tts'
+Provides-Extra: vad
+Requires-Dist: numpy>=2.4.6; extra == 'vad'
+Requires-Dist: torch>=2.10.0; extra == 'vad'
+Requires-Dist: torchaudio>=2.10.0; extra == 'vad'
+Provides-Extra: wake
+Requires-Dist: local-wake>=0.1.1; extra == 'wake'
+Description-Content-Type: text/markdown
+
+# MiscAI
+Tools to make it easier to embed AI related things into your exsisting projects.
+
+## Features
+- Ollama local LLM wrapper (with build-in Jina embeddings model)
+- Mercury diffusion language model (with the same embeddings as with Ollama, requires a mercury API key)
+- Easy tool function creation with both types of language models
+- Whisper-cpp speech to text
+- Text to speech cloning with pocket-tts (requires a hugging face account)
+- Voice activity detection with silero
+- Wakeword detection with local wake
+
+## Ollama local LLM
+To use the local LLM with Ollama the host has to have Ollama installed already. The embeddings model is ran on the CPU as it is light and performant enough. Then install it into the python project with:
+```sh
+pip install miscai[llm]
+```
+Here is an example of how to use it:
+```python
+from miscai.llm import LLM
+
+llm = LLM(promt="You are helpful assistant.", model="qwen3:4b", convo_file="./convo.json")
+print(llm.ask_LLM("Hello!"))
+```
+
+## Diffusion Language Model (DLM)
+Use of the DLM module is very similar to using the local LLM. You will need to make a Mercury API key to use the wrapper. The embeddings model is ran on the CPU as it is light and performant enough. Then install it into the python project with:
+```sh
+pip install miscai[dlm]
+```
+Here is an example of how to use it:
+```python
+from miscai.dlm import DLM
+
+dlm = DLM(promt="You are helpful assistant.", model="mercury-v2", convo_file="./convo.json", api_key="123abc")
+print(dlm.ask_LLM("Hello!"))
+```
+
+## Tool calling for Language models
+This requires that you have installed one of the language models above. Here is an example of how to use it in a project:
+```python
+from miscai.tools import ToolLoader
+
+tool_loader = ToolLoader("./tools")
+```
+Then when you are creating your language model object, create it like this (using the Ollama one for example):
+```python
+llm = LLM(promt="You are helpful assistant.", model="qwen3:4b", convo_file="./convo.json", tools=tool_loader.get_tools())
+```
+To create a tool, install the required dependencies to your project and place the python file in the directory specified in the ToolLoader object. Here is an example tool that gets the time with the 'pytz' package:
+```python
+import pytz
+from datetime import datetime
+
+tool = {
+    "type": "function",
+    "function": {
+        "name": "get_current_time",
+        "description": "Gets the current time for a provided time zone.",
+        'parameters': {
+            "type": "object",
+            "properties": {
+                "timezone": {
+                    "type": "string",
+                    "description": "The time zone as specified in the tz (zoneinfo) library."
+                }
+            },
+            "required": ["timezone"]
+        }
+    }
+}
+
+def get_current_time(timezone: str) -> str:
+    tz = pytz.timezone(timezone)
+    return str(datetime.now(tz))
+```
+
+## Speech to text
+The whisper-cpp model is ran on the CPU but is quite performant and accurate, but may use a lot of CPU. The audio bytes are in a numpy array encoded at 16000kHz with 512 byte chunks. Install it into your project with:
+```sh
+pip install miscai[stt]
+```
+Here is an example of how to use it:
+```python
+from miscai.stt import STT
+
+stt = STT()
+print(stt.transcribe(audio_bytes=audio_bytes))
+```
+
+## Text to speech
+You will have to create a hugging face account and accept the eula for using the pocket-tts model. Then create an API key as you will need this later. The model is ran on the CPU for reason mentioned on the model's page. The audio base needs to be encoded with 16000kHz for the best results. The outputed audio is a numpy array. Then install it into the project using:
+```sh
+pip install miscai[tts]
+```
+Here is an example of how to use it:
+```python
+from miscai.tts import TTS
+
+tts = TTS("./voice_base.wav")
+audio = tts.get_audio("Hello!")
+```
+
+## Voice activity detection
+This uses Silero VAD for voice detection and it runs on the CPU due to the model being light weight enough. The audio bytes inputed is a numpy array with 512 byte chunks. For best results the audio should be encoded in 16000kHz. Install it into your project with:
+```sh
+pip install miscai[vad]
+```
+Here is an example of how to use it:
+```python
+from miscai.vad import VAD
+
+vad = VAD(threshold=0.5)
+print(vad.is_speech(audio_bytes=audio_bytes))
+```
+
+## Wakeword detection
+This uses local-wake and so any audio file of any person saying the wakeword works as the wakeword. The audio inputed is a audio stream with 512 byte chunks (best gotten through SoundDevice). For best results the audio for the input and the audio for the reference audio files should be encoded in 16000kHz. Install it into your project with:
+```sh
+pip install miscai[wake]
+```
+Here is an example of how to use it:
+```python
+from miscai.wakeword import WakeWord
+
+wake_word = WakeWord(threshold=0.5, audio_dir="./wakeword")
+print("Begining to wait for wakeword")
+wake_word.waitForWord(callback=awoke, stream=stream)
+
+def awoke(detection: dict, stream: sd.InputStream):
+    print(f"Wake word detected: {detection['wakeword']}")
+```
+
+## Final notes
+This project is in quite an early stage and could do with some more polish. It is not meant to be used in production but is good for making small prototypes for different ideas that you may have. I made this to make it easier to implement LLMs into my other projects and it grew from there. Changes are welcome as the documention is hastely written and the codes is arguable worse. Thanks for reading and maybe using this. :)

miscai-0.1.0/README.md

@@ -0,0 +1,135 @@
+# MiscAI
+Tools to make it easier to embed AI related things into your exsisting projects.
+
+## Features
+- Ollama local LLM wrapper (with build-in Jina embeddings model)
+- Mercury diffusion language model (with the same embeddings as with Ollama, requires a mercury API key)
+- Easy tool function creation with both types of language models
+- Whisper-cpp speech to text
+- Text to speech cloning with pocket-tts (requires a hugging face account)
+- Voice activity detection with silero
+- Wakeword detection with local wake
+
+## Ollama local LLM
+To use the local LLM with Ollama the host has to have Ollama installed already. The embeddings model is ran on the CPU as it is light and performant enough. Then install it into the python project with:
+```sh
+pip install miscai[llm]
+```
+Here is an example of how to use it:
+```python
+from miscai.llm import LLM
+
+llm = LLM(promt="You are helpful assistant.", model="qwen3:4b", convo_file="./convo.json")
+print(llm.ask_LLM("Hello!"))
+```
+
+## Diffusion Language Model (DLM)
+Use of the DLM module is very similar to using the local LLM. You will need to make a Mercury API key to use the wrapper. The embeddings model is ran on the CPU as it is light and performant enough. Then install it into the python project with:
+```sh
+pip install miscai[dlm]
+```
+Here is an example of how to use it:
+```python
+from miscai.dlm import DLM
+
+dlm = DLM(promt="You are helpful assistant.", model="mercury-v2", convo_file="./convo.json", api_key="123abc")
+print(dlm.ask_LLM("Hello!"))
+```
+
+## Tool calling for Language models
+This requires that you have installed one of the language models above. Here is an example of how to use it in a project:
+```python
+from miscai.tools import ToolLoader
+
+tool_loader = ToolLoader("./tools")
+```
+Then when you are creating your language model object, create it like this (using the Ollama one for example):
+```python
+llm = LLM(promt="You are helpful assistant.", model="qwen3:4b", convo_file="./convo.json", tools=tool_loader.get_tools())
+```
+To create a tool, install the required dependencies to your project and place the python file in the directory specified in the ToolLoader object. Here is an example tool that gets the time with the 'pytz' package:
+```python
+import pytz
+from datetime import datetime
+
+tool = {
+    "type": "function",
+    "function": {
+        "name": "get_current_time",
+        "description": "Gets the current time for a provided time zone.",
+        'parameters': {
+            "type": "object",
+            "properties": {
+                "timezone": {
+                    "type": "string",
+                    "description": "The time zone as specified in the tz (zoneinfo) library."
+                }
+            },
+            "required": ["timezone"]
+        }
+    }
+}
+
+def get_current_time(timezone: str) -> str:
+    tz = pytz.timezone(timezone)
+    return str(datetime.now(tz))
+```
+
+## Speech to text
+The whisper-cpp model is ran on the CPU but is quite performant and accurate, but may use a lot of CPU. The audio bytes are in a numpy array encoded at 16000kHz with 512 byte chunks. Install it into your project with:
+```sh
+pip install miscai[stt]
+```
+Here is an example of how to use it:
+```python
+from miscai.stt import STT
+
+stt = STT()
+print(stt.transcribe(audio_bytes=audio_bytes))
+```
+
+## Text to speech
+You will have to create a hugging face account and accept the eula for using the pocket-tts model. Then create an API key as you will need this later. The model is ran on the CPU for reason mentioned on the model's page. The audio base needs to be encoded with 16000kHz for the best results. The outputed audio is a numpy array. Then install it into the project using:
+```sh
+pip install miscai[tts]
+```
+Here is an example of how to use it:
+```python
+from miscai.tts import TTS
+
+tts = TTS("./voice_base.wav")
+audio = tts.get_audio("Hello!")
+```
+
+## Voice activity detection
+This uses Silero VAD for voice detection and it runs on the CPU due to the model being light weight enough. The audio bytes inputed is a numpy array with 512 byte chunks. For best results the audio should be encoded in 16000kHz. Install it into your project with:
+```sh
+pip install miscai[vad]
+```
+Here is an example of how to use it:
+```python
+from miscai.vad import VAD
+
+vad = VAD(threshold=0.5)
+print(vad.is_speech(audio_bytes=audio_bytes))
+```
+
+## Wakeword detection
+This uses local-wake and so any audio file of any person saying the wakeword works as the wakeword. The audio inputed is a audio stream with 512 byte chunks (best gotten through SoundDevice). For best results the audio for the input and the audio for the reference audio files should be encoded in 16000kHz. Install it into your project with:
+```sh
+pip install miscai[wake]
+```
+Here is an example of how to use it:
+```python
+from miscai.wakeword import WakeWord
+
+wake_word = WakeWord(threshold=0.5, audio_dir="./wakeword")
+print("Begining to wait for wakeword")
+wake_word.waitForWord(callback=awoke, stream=stream)
+
+def awoke(detection: dict, stream: sd.InputStream):
+    print(f"Wake word detected: {detection['wakeword']}")
+```
+
+## Final notes
+This project is in quite an early stage and could do with some more polish. It is not meant to be used in production but is good for making small prototypes for different ideas that you may have. I made this to make it easier to implement LLMs into my other projects and it grew from there. Changes are welcome as the documention is hastely written and the codes is arguable worse. Thanks for reading and maybe using this. :)

miscai-0.1.0/pyproject.toml

@@ -0,0 +1,45 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "miscai"
+version = "0.1.0"
+description = "Miscellaneous differnet AI tools for embedding into projects."
+readme = "README.md"
+requires-python = ">=3.14"
+license = { file = "LICENSE" }
+
+# Optional component dependencies
+[project.optional-dependencies]
+dlm = [
+    "chromadb>=1.5.2",
+    "torch>=2.10.0",
+    "transformers>=4.57.3",
+    "requests>=2.34.2",
+    "peft>=0.19.1",
+]
+llm = [
+    "chromadb>=1.5.2",
+    "torch>=2.10.0",
+    "transformers>=4.57.3",
+    "ollama>=0.6.1",
+    "peft>=0.19.1",
+]
+stt = [
+    "numpy>=2.4.6",
+    "pywhispercpp>=1.4.1",
+]
+tts = [
+    "numpy>=2.4.6",
+    "pocket-tts>=1.1.1",
+    "scipy>=1.17.1",
+]
+vad = [
+    "torch>=2.10.0",
+    "torchaudio>=2.10.0",
+    "numpy>=2.4.6",
+]
+wake = [
+    "local-wake>=0.1.1",
+]

miscai-0.1.0/src/miscai/dlm.py

@@ -0,0 +1,195 @@
+import re
+import json
+try:
+    import torch
+    import chromadb
+    import requests
+    from transformers import AutoModel
+    from chromadb import EmbeddingFunction, Embeddings, Documents
+except:
+    raise ImportError("The 'dlm' module is required to use this. Install it with 'pip install miscai[dlm]'.")
+
+class DLM():
+    def __init__(self, 
+                 promt: str, 
+                 model: str, 
+                 convo_file: str,
+                 api_key: str,
+                 tools: tuple = (None, None), 
+                 think: str = "high",
+                 ) -> None:
+        self.PROMT = promt
+        self.MODEL = model
+        self.API_KEY = api_key
+        
+        self.tools_def, self.tools_fn = tools
+        self.think = think
+        self.convo_file = convo_file
+
+        self.jina_model = AutoModel.from_pretrained(
+            "jinaai/jina-embeddings-v5-text-small",
+            trust_remote_code=True,
+            dtype=torch.bfloat16,
+            attn_implementation="sdpa"
+        )
+        self.jina_model = self.jina_model.to("cpu")
+
+        chroma_client = chromadb.PersistentClient(path="./memory_db")
+        self.collection = chroma_client.get_or_create_collection(
+            name="ltm",
+            embedding_function=self.JinaEmbeddingFunction(self.jina_model)
+        )
+
+        self.query_ef = self.JinaQueryEmbeddingFunction(self.jina_model)
+
+        try:
+            with open(self.convo_file, "r") as file:
+                self.messages = json.load(file)
+                self.msg_count = len(self.messages)
+        except:
+            self.messages = []
+            self.msg_count = 0
+
+    def save_memory(self, text: str, memory_id: str) -> None:
+        self.collection.upsert(documents=[text], ids=[memory_id])
+
+    def retrieve_memories(self, query: str, n: int = 3) -> str:
+        query_embedding = self.query_ef([query])[0]
+        results = self.collection.query(query_embeddings=[query_embedding], n_results=n)
+        docs = results["documents"][0] # type: ignore
+        return "\n".join(docs) if docs else ""
+    
+    def ask_LLM(self, text: str) -> str:
+        system_prompt = self.PROMT
+
+        memories = self.retrieve_memories(text)
+        if memories:
+            system_prompt += f"\n\nRelevant memories:\n{memories}"
+
+        self.messages.append({"role": "user", "content": text})
+
+        resp = requests.post(
+            "https://api.inceptionlabs.ai/v1/chat/completions",
+            headers={
+                'Content-Type': 'application/json',
+                'Authorization': f'Bearer {self.API_KEY}'
+            },
+            json={
+                "model": self.MODEL,
+                "messages": [{"role": "system", "content": system_prompt}] + self.messages[-10:],
+                "reasoning_effort": self.think,
+                "tools": self.tools_def
+            }
+        )
+        resp_j = resp.json()
+        print(f"API response: {resp_j}")
+
+        reply = resp_j["choices"][0]["message"]["content"] or ""
+        self.messages.append(self._serialize_assistant_message(resp_j["choices"][0]["message"]))
+        print(f"\n{reply}\n")
+
+        while resp_j["choices"][0]["message"]["tool_calls"]:
+            result = self.call_tools(resp_j["choices"][0]["message"]["tool_calls"]) # type: ignore
+            self.messages.extend(result)
+
+            resp = requests.post(
+                "https://api.inceptionlabs.ai/v1/chat/completions",
+                headers={
+                    'Content-Type': 'application/json',
+                    'Authorization': f'Bearer {self.API_KEY}'
+                },
+                json={
+                    "model": self.MODEL,
+                    "messages": [{"role": "system", "content": system_prompt}] + self.messages[-10:],
+                    "reasoning_effort": self.think,
+                    "tools": self.tools_def
+                }
+            )
+
+            resp_j = resp.json()
+            print(f"API response: {resp_j}")
+            reply = resp_j["choices"][0]["message"]["content"] or ""
+
+            self.messages.append(self._serialize_assistant_message(resp_j["choices"][0]["message"]))
+            print(f"\n{reply}\n")
+
+        self.msg_count += 1
+        self.save_memory(
+            f"User: {text}\nAssistant: {reply}",
+            memory_id=f"msg_{self.msg_count}"
+        )
+
+        with open(self.convo_file, "w") as file:
+            json.dump(self.messages, file)
+
+        return re.sub(r".*?</think>", "", reply, flags=re.DOTALL).strip()
+    
+    def call_tools(self, tool_calls: list) -> list:
+        results = []
+
+        for call in tool_calls:
+            fn = call["function"]
+            fn_name = fn["name"]
+            fn_args = json.loads(fn["arguments"]) if fn["arguments"] else {}
+
+            if fn_name in self.tools_fn:
+                print(f"CALLING TOOL {fn_name}({fn_args})")
+                try:
+                    out = self.tools_fn[fn_name](**fn_args)
+                    content = str(out) if out is not None else "Done."
+                except Exception as e:
+                    content = f"Error: {e}"
+            else:
+                content = f"Unknown tool: {fn_name}"
+
+            results.append({
+                "role": "tool",
+                "content": content,
+                "tool_call_id": call.get("id", fn_name)  # call is a dict, use .get()
+            })
+
+        return results
+
+    def _serialize_assistant_message(self, message) -> dict:
+        msg = {"role": "assistant", "content": message.get("content") or ""}
+        tool_calls = message.get("tool_calls")
+        if tool_calls:
+            msg["tool_calls"] = [
+                {
+                    "id": tc.get("id", tc["function"]["name"]),
+                    "function": {
+                        "name": tc["function"]["name"],
+                        "arguments": tc["function"]["arguments"]  # keep as raw string
+                    }
+                }
+                for tc in tool_calls
+            ]
+        return msg
+
+    class JinaEmbeddingFunction(EmbeddingFunction):
+        def __init__(self, model) -> None:
+            super().__init__()
+
+            self.jina_model = model
+
+        def __call__(self, input: Documents) -> Embeddings:
+            embedings = self.jina_model.encode(
+                texts=input,
+                task="retrieval",
+                prompt_name="document"
+            )
+            return embedings.tolist()
+
+    class JinaQueryEmbeddingFunction(EmbeddingFunction):
+        def __init__(self, model) -> None:
+            super().__init__()
+
+            self.jina_model = model
+
+        def __call__(self, input: Documents) -> Embeddings:
+            embeddings = self.jina_model.encode(
+                texts=input,
+                task="retrieval",
+                prompt_name="query"
+            )
+            return embeddings.tolist()

miscai-0.1.0/src/miscai/llm.py

@@ -0,0 +1,190 @@
+import re
+import json
+try:
+    import torch
+    import chromadb
+    from transformers import AutoModel
+    from chromadb import EmbeddingFunction, Embeddings, Documents
+    from ollama import chat
+    from ollama import ChatResponse
+except:
+    raise ImportError("The 'llm' module is required to use this. Install it with 'pip install miscai[llm]'.")
+
+class LLM():
+    def __init__(self, 
+                 promt: str, 
+                 model: str, 
+                 convo_file: str,
+                 tools: tuple = (None, None), 
+                 think: bool = True,
+                 ) -> None:
+        self.PROMT = promt
+        self.MODEL = model
+        
+        self.tools_def, self.tools_fn = tools
+        self.think = think
+        self.convo_file = convo_file
+
+        self.jina_model = AutoModel.from_pretrained(
+            "jinaai/jina-embeddings-v5-text-small",
+            trust_remote_code=True,
+            dtype=torch.bfloat16,
+            attn_implementation="sdpa"
+        )
+        self.jina_model = self.jina_model.to("cpu")
+
+        chroma_client = chromadb.PersistentClient(path="./memory_db")
+        self.collection = chroma_client.get_or_create_collection(
+            name="ltm",
+            embedding_function=self.JinaEmbeddingFunction(self.jina_model)
+        )
+
+        self.query_ef = self.JinaQueryEmbeddingFunction(self.jina_model)
+
+        try:
+            with open(self.convo_file, "r") as file:
+                self.messages = json.load(file)
+                self.msg_count = len(self.messages)
+        except:
+            self.messages = []
+            self.msg_count = 0
+
+    def save_memory(self, text: str, memory_id: str) -> None:
+        self.collection.upsert(documents=[text], ids=[memory_id])
+
+    def retrieve_memories(self, query: str, n: int = 3) -> str:
+        query_embedding = self.query_ef([query])[0]
+        results = self.collection.query(query_embeddings=[query_embedding], n_results=n)
+        docs = results["documents"][0] # type: ignore
+        return "\n".join(docs) if docs else ""
+    
+    def _parse_arguments(self, arguments) -> dict:
+        """Ensure tool call arguments are always a dict, never a JSON string."""
+        if isinstance(arguments, dict):
+            return arguments
+        if isinstance(arguments, str):
+            try:
+                parsed = json.loads(arguments)
+                return parsed if isinstance(parsed, dict) else {}
+            except (json.JSONDecodeError, ValueError):
+                return {}
+        return dict(arguments) if arguments else {}
+
+    def ask_LLM(self, text: str) -> str:
+        system_prompt = self.PROMT
+
+        memories = self.retrieve_memories(text)
+        if memories:
+            system_prompt += f"\n\nRelevant memories:\n{memories}"
+
+        self.messages.append({"role": "user", "content": text})
+
+        resp: ChatResponse = chat(
+            model=self.MODEL,
+            messages=[{"role": "system", "content": system_prompt}] + self.messages[-10:],
+            stream=False,
+            think=self.think,
+            tools=self.tools_def
+        )
+
+        reply = resp.message.content or ""
+        self.messages.append(self._serialize_assistant_message(resp.message))
+        print(f"\n{reply}\n")
+
+        while resp.message.tool_calls:
+            result = self.call_tools(resp.message.tool_calls) # type: ignore
+            self.messages.extend(result)
+
+            resp: ChatResponse = chat(
+                model=self.MODEL,
+                messages=[{"role": "system", "content": system_prompt}] + self.messages[-10:],
+                stream=False,
+                think=self.think,
+                tools=self.tools_def
+            )
+
+            reply = resp.message.content or ""
+            self.messages.append(self._serialize_assistant_message(resp.message))
+            print(f"\n{reply}\n")
+
+        self.msg_count += 1
+        self.save_memory(
+            f"User: {text}\nAssistant: {reply}",
+            memory_id=f"msg_{self.msg_count}"
+        )
+
+        with open(self.convo_file, "w") as file:
+            json.dump(self.messages, file)
+
+        return re.sub(r".*?</think>", "", reply, flags=re.DOTALL).strip()
+    
+    def call_tools(self, tool_calls: list) -> list:
+        results = []
+
+        for call in tool_calls:
+            fn = call.function
+            fn_name = fn.name
+            fn_args = self._parse_arguments(fn.arguments)
+
+            if fn_name in self.tools_fn:
+                print(f"CALLING TOOL {fn_name}({fn_args})")
+                try:
+                    out = self.tools_fn[fn_name](**fn_args)
+                    content = str(out) if out is not None else "Done."
+                except Exception as e:
+                    content = f"Error: {e}"
+            else:
+                content = f"Unknown tool: {fn_name}"
+
+            results.append({
+                "role": "tool",
+                "content": content,
+                "tool_call_id": getattr(call, "id", fn_name)
+            })
+
+        return results
+
+    def _serialize_assistant_message(self, message) -> dict:
+        msg = {"role": "assistant", "content": message.content or ""}
+        tool_calls = message.tool_calls
+        if tool_calls:
+            msg["tool_calls"] = [
+                {
+                    "id": getattr(tc, "id", tc.function.name),
+                    "function": {
+                        "name": tc.function.name,
+                        # Always store as dict so reloaded messages stay valid
+                        "arguments": self._parse_arguments(tc.function.arguments)
+                    }
+                }
+                for tc in tool_calls
+            ]
+        return msg
+
+    class JinaEmbeddingFunction(EmbeddingFunction):
+        def __init__(self, model) -> None:
+            super().__init__()
+
+            self.jina_model = model
+
+        def __call__(self, input: Documents) -> Embeddings:
+            embedings = self.jina_model.encode(
+                texts=input,
+                task="retrieval",
+                prompt_name="document"
+            )
+            return embedings.tolist()
+
+    class JinaQueryEmbeddingFunction(EmbeddingFunction):
+        def __init__(self, model) -> None:
+            super().__init__()
+
+            self.jina_model = model
+
+        def __call__(self, input: Documents) -> Embeddings:
+            embeddings = self.jina_model.encode(
+                texts=input,
+                task="retrieval",
+                prompt_name="query"
+            )
+            return embeddings.tolist()

miscai-0.1.0/src/miscai/stt.py

@@ -0,0 +1,19 @@
+import io
+try:
+    import numpy as np
+    from pywhispercpp.model import Model
+except:
+    raise ImportError("The 'stt' module is required to use this. Install it with 'pip install miscai[stt]'.")
+
+class STT():
+    def __init__(self) -> None:
+        self.model = Model('base.en')
+    
+    def transcribe(self, audio_bytes: np.ndarray) -> str:
+        segments = self.model.transcribe(audio_bytes)
+        
+        final = ""
+        for segment in segments:
+            final += segment.text + "\n"
+
+        return final

miscai-0.1.0/src/miscai/tools.py

@@ -0,0 +1,38 @@
+import os
+import importlib.util
+
+class ToolLoader():
+    def __init__(self, tools_dir: str) -> None:
+        self.tools_dir = tools_dir
+
+    def get_tools(self) -> tuple[list, dict]:
+        tools_list = []
+        func_map = {}
+
+        for filename in os.listdir(self.tools_dir):
+            if not filename.endswith(".py") or filename.startswith("_"):
+                continue
+
+            module_name = filename[:-3]
+            filepath = os.path.join(self.tools_dir, filename)
+
+            spec = importlib.util.spec_from_file_location(module_name, filepath)
+            module = importlib.util.module_from_spec(spec) # type: ignore
+            spec.loader.exec_module(module) # type: ignore
+
+            if not hasattr(module, "tool"):
+                print(f"TOOL: {filename} DOESN'T HAVE TOOL DEFINITION!")
+                continue
+
+            tool_def = module.tool
+            fn_name = tool_def["function"]["name"]
+
+            if not hasattr(module, fn_name):
+                print(f"TOOL {filename}'S FUNCTION DOESN'T MATCH DEFINITION!")
+                continue
+
+            tools_list.append(tool_def)
+            func_map[fn_name] = getattr(module, fn_name)
+            print(f"LOADED {filename} SUCCESSFULLY!")
+
+        return tools_list, func_map

miscai-0.1.0/src/miscai/tts.py

@@ -0,0 +1,22 @@
+import math
+try:
+    import numpy as np
+    from pocket_tts import TTSModel
+    from scipy.signal import resample_poly
+except:
+    raise ImportError("The 'tts' module is required to use this. Install it with 'pip install miscai[tts]'.")
+
+class TTS():
+    def __init__(self, voice_base_file: str) -> None:
+        self.tts_model = TTSModel.load_model()
+        self.voice_state = self.tts_model.get_state_for_audio_prompt(
+            voice_base_file
+        )
+
+    def get_audio(self, text: str):
+        audio = self.tts_model.generate_audio(self.voice_state, text)
+        
+        gcd = math.gcd(self.tts_model.sample_rate, 44100)
+        audio_resamp = resample_poly(audio.numpy(), 44100 // gcd, self.tts_model.sample_rate // gcd).astype(np.float32)
+
+        return audio_resamp, 44100

miscai-0.1.0/src/miscai/vad.py

@@ -0,0 +1,24 @@
+try:
+    import torch
+    import numpy as np
+except:
+    raise ImportError("The 'vad' module is required to use this. Install it with 'pip install miscai[vad]'.")
+
+class VAD():
+    def __init__(self, threshold: float) -> None:
+        self.model, self.utils = torch.hub.load(repo_or_dir='snakers4/silero-vad', model='silero_vad') # type: ignore
+
+        self.SAMPLING_RATE = 16000
+        self.CHUNK = 512
+        self.THRESHOLD = threshold
+    
+    def is_speech(self, audio_bytes: np.ndarray) -> bool:
+        audio_np = audio_bytes.flatten().astype(np.float32)
+        audio_tensor = torch.from_numpy(audio_np)
+        
+        speech_prob = self.model(audio_tensor, self.SAMPLING_RATE).item()
+
+        if speech_prob > self.THRESHOLD:
+            return True
+        else:
+            return False

miscai-0.1.0/src/miscai/wakeword.py

@@ -0,0 +1,12 @@
+try:
+    import lwake
+except:
+    raise ImportError("The 'wake' module is required to use this. Install it with 'pip install miscai[wake]'.")
+
+class WakeWord():
+    def __init__(self, threshold: float, audio_dir: str) -> None:
+        self.THRESHOLD = threshold
+        self.REF_DIR = audio_dir
+
+    def waitForWord(self, callback, stream = None ) -> None:
+        lwake.listen(self.REF_DIR, threshold=self.THRESHOLD, method="embedding", callback=callback, stream=stream)