agently 4.0.5.5__tar.gz → 4.0.5.6__tar.gz

{agently-4.0.5.5 → agently-4.0.5.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agently
-Version: 4.0.5.5
+Version: 4.0.5.6
 Summary: 
 License: Apache-2.0
 License-File: LICENSE

{agently-4.0.5.5 → agently-4.0.5.6}/agently/builtins/plugins/ModelRequester/OpenAICompatible.py

@@ -184,13 +184,25 @@ class OpenAICompatible(ModelRequester):
                 request_data = {"prompt": self.prompt.to_text()}
             case "embeddings":
                 sanitized_input = DataFormatter.sanitize(self.prompt["input"])
-                request_data = {
-                    "input": (
-                        str(sanitized_input)
-                        if isinstance(sanitized_input, (str, int, float, bool)) or sanitized_input is None
-                        else yaml.safe_dump(sanitized_input)
-                    )
-                }
+                if isinstance(sanitized_input, list):
+                    request_data = {
+                        "input": [
+                            (
+                                str(item)
+                                if isinstance(item, (str, int, float, bool)) or item is None
+                                else yaml.safe_dump(item)
+                            )
+                            for item in sanitized_input
+                        ],
+                    }
+                else:
+                    request_data = {
+                        "input": (
+                            str(sanitized_input)
+                            if isinstance(sanitized_input, (str, int, float, bool)) or sanitized_input is None
+                            else yaml.safe_dump(sanitized_input)
+                        )
+                    }
             case _:
                 self._messenger.error(
                     TypeError(
@@ -266,7 +278,10 @@ class OpenAICompatible(ModelRequester):
         ## !: ensure stream
         is_stream = self.plugin_settings.get("stream")
         if is_stream is None:
-            is_stream = True
+            if self.model_type == "embeddings":
+                is_stream = False
+            else:
+                is_stream = True
         request_options.update({"stream": is_stream})
         ## set
         agently_request_dict["request_options"] = request_options
@@ -536,6 +551,9 @@ class OpenAICompatible(ModelRequester):
                             yield "extra", {extra_key: extra_value}
             else:
                 done_content = None
+                if self.model_type == "embeddings" and done_mapping is None:
+                    done_mapping = "data"
+                    content_mapping_style = "dot"
                 if done_mapping:
                     done_content = DataLocator.locate_path_in_dict(
                         message_record,
@@ -546,16 +564,20 @@ class OpenAICompatible(ModelRequester):
                     yield "done", done_content
                 else:
                     yield "done", content_buffer
-                done_message = message_record
-                if "message" not in done_message["choices"][0]:
-                    done_message["choices"][0].update({"message": {}})
-                done_message["choices"][0]["message"].update(
-                    {
-                        "role": meta["role"] if "role" in meta else "assistant",
-                        "content": done_content if done_content else content_buffer,
-                    }
-                )
-                yield "original_done", done_message
+                match self.model_type:
+                    case "embeddings":
+                        yield "original_done", message_record
+                    case "_":
+                        done_message = message_record
+                        if "message" not in done_message["choices"][0]:
+                            done_message["choices"][0].update({"message": {}})
+                        done_message["choices"][0]["message"].update(
+                            {
+                                "role": meta["role"] if "role" in meta else "assistant",
+                                "content": done_content if done_content else content_buffer,
+                            }
+                        )
+                        yield "original_done", done_message
                 if finish_reason_mapping:
                     meta.update(
                         {

{agently-4.0.5.5 → agently-4.0.5.6}/agently/builtins/plugins/ResponseParser/AgentlyResponseParser.py

@@ -153,12 +153,12 @@ class AgentlyResponseParser(ResponseParser):
                         self.full_result_data["original_done"] = data
                     case "done":
                         self.full_result_data["text_result"] = str(data)
-                        if buffer != self.full_result_data["text_result"]:
-                            warnings.warn(
-                                "Buffered streaming result is not exactly the same as final result.\n"
-                                f"Buffered Result: { buffer }\n"
-                                f"Final Result: { self.full_result_data['text_result'] }\n"
-                            )
+                        # if buffer != self.full_result_data["text_result"]:
+                        #     warnings.warn(
+                        #         "Buffered streaming result is not exactly the same as final result.\n"
+                        #         f"Buffered Result: { buffer }\n"
+                        #         f"Final Result: { self.full_result_data['text_result'] }\n"
+                        #     )
                         if self._prompt_object.output_format == "json":
                             cleaned_json = DataLocator.locate_output_json(str(data), self._prompt_object.output)
                             if cleaned_json:
@@ -204,7 +204,14 @@ class AgentlyResponseParser(ResponseParser):
                                     self.settings,
                                 )
                         else:
-                            self.full_result_data["parsed_result"] = str(data)
+                            if (
+                                isinstance(data, list)
+                                and isinstance(data[0], dict)
+                                and "object" in data[0]
+                                and data[0]["object"] == "embedding"
+                            ):
+                                data = [item["embedding"] for item in data]
+                            self.full_result_data["parsed_result"] = data
                             if self.settings.get("$log.cancel_logs") is not True:
                                 await async_system_message(
                                     "MODEL_REQUEST",

agently-4.0.5.6/agently/integrations/chromadb.py

@@ -0,0 +1,86 @@
+from agently.utils import LazyImport
+
+LazyImport.import_package("chromadb")
+
+import json
+
+from chromadb.api.types import EmbeddingFunction, Documents, Embedding, Embeddings
+
+from typing import Callable, TypedDict, Any, cast
+from agently.core import BaseAgent
+
+
+class ChromaDataDictOptional(TypedDict, total=False):
+    metadata: dict[Any, Any]
+    id: Any
+    embedding: Embedding
+
+
+class ChromaDataDict(ChromaDataDictOptional):
+    document: str
+
+
+class ChromaData:
+    def __init__(
+        self,
+        original_data: ChromaDataDict | list[ChromaDataDict],
+        *,
+        embedding_function: Callable[[str | list[str]], Embeddings] | None = None,
+        agent: BaseAgent | None = None,
+    ):
+        self._original_data = original_data if isinstance(original_data, list) else [original_data]
+        if embedding_function:
+            self._embedding_function = embedding_function
+        elif agent:
+
+            def embedding_function_by_agent(texts: str | list[str]) -> Embeddings:
+                return agent.input(texts).start()
+
+            self._embedding_function = embedding_function_by_agent
+        else:
+            self._embedding_function = None
+        self._chroma_data = {
+            "documents": [],
+            "metadatas": [],
+            "ids": [],
+            "embeddings": [],
+        }
+        if self._embedding_function is not None:
+            documents = [data["document"] for data in self._original_data]
+            embeddings = self._embedding_function(documents)
+            self._chroma_data["embeddings"] = embeddings
+            for index, data in enumerate(self._original_data):
+                data["embedding"] = embeddings[index]
+        else:
+            del self._chroma_data["embeddings"]
+        for index, data in enumerate(self._original_data):
+            self._chroma_data["documents"].append(data["document"])
+            self._chroma_data["metadatas"].append(data["metadata"] if "metadata" in data else None)
+            self._chroma_data["ids"].append(data["id"] if "id" in data else str(index))
+
+    def get_kwargs(self):
+        return self._chroma_data
+
+    def get_original_data(self):
+        return self._original_data
+
+
+class ChromaEmbeddingFunction(EmbeddingFunction):
+    def __init__(
+        self, *, embedding_function: Callable[[list[str]], Embeddings] | None = None, agent: BaseAgent | None = None
+    ):
+        if embedding_function:
+            self.embedding_function = embedding_function
+        elif agent:
+
+            def embedding_function_by_agent(texts: list[str]) -> Embeddings:
+                return agent.input(texts).start()
+
+            self.embedding_function = embedding_function_by_agent
+        else:
+            raise ValueError(
+                f"ChromaEmbeddingFunction() requires at least one definition for 'embedding_function' or 'agent'."
+            )
+
+    def __call__(self, documents: Documents) -> Embeddings:
+        return self.embedding_function([document for document in documents])

{agently-4.0.5.5 → agently-4.0.5.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "agently"
-version = "4.0.5.5"
+version = "4.0.5.6"
 description = ""
 authors = [
     {name = "Agently Team",email = "developer@agently.tech"},