agently 4.0.6.6__tar.gz → 4.0.6.8__tar.gz

{agently-4.0.6.6 → agently-4.0.6.8}/PKG-INFO

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

{agently-4.0.6.6 → agently-4.0.6.8}/agently/builtins/agent_extensions/ConfigurePromptExtension.py

@@ -188,6 +188,7 @@ class ConfigurePromptExtension(BaseAgent):
                 "Cannot execute YAML prompt configures, expect prompt configures as a dictionary data but got:"
                 f"{ prompt }"
             )
+        return self
 
     def load_json_prompt(self, path_or_content: str, mappings: dict[str, Any] | None = None):
         path = Path(path_or_content)
@@ -209,3 +210,4 @@ class ConfigurePromptExtension(BaseAgent):
                 "Cannot execute JSON prompt configures, expect prompt configures as a dictionary data but got:"
                 f"{ prompt }"
             )
+        return self

{agently-4.0.6.6 → agently-4.0.6.8}/agently/builtins/plugins/ModelRequester/OpenAICompatible.py

@@ -351,13 +351,13 @@ class OpenAICompatible(ModelRequester):
         api_key = self.plugin_settings.get("api_key", None)
         if api_key is not None and auth["api_key"] == "None":
             auth["api_key"] = str(api_key)
-        if "api_key" in auth:
-            headers_with_auth = {**request_data.headers, "Authorization": f"Bearer { auth['api_key'] }"}
-        elif "headers" in auth and isinstance(auth["headers"], dict):
+        if "headers" in auth and isinstance(auth["headers"], dict):
             headers_with_auth = {**request_data.headers, **auth["headers"]}
         elif "body" in auth and isinstance(auth["body"], dict):
             headers_with_auth = request_data.headers.copy()
             request_data.data.update(**auth["body"])
+        if "api_key" in auth and auth["api_key"] != "None":
+            headers_with_auth = {**request_data.headers, "Authorization": f"Bearer { auth['api_key'] }"}
         else:
             headers_with_auth = request_data.headers.copy()
 

{agently-4.0.6.6 → agently-4.0.6.8}/agently/builtins/plugins/PromptGenerator/AgentlyPromptGenerator.py

@@ -649,7 +649,12 @@ class AgentlyPromptGenerator(PromptGenerator):
                         }
                     )
 
-            return create_model(name, **fields, **validators)
+            return create_model(
+                name,
+                __config__={'extra': 'allow'},
+                **fields,
+                **validators,
+            )
         else:
             item_type = Any
             if len(schema) > 0:

{agently-4.0.6.6 → agently-4.0.6.8}/agently/core/ModelRequest.py

@@ -22,12 +22,13 @@ ContentKindTuple: TypeAlias = Literal["all", "delta", "original"]
 ContentKindStreaming: TypeAlias = Literal["instant", "streaming_parse"]
 
 from agently.core import Prompt, ExtensionHandlers
-from agently.utils import Settings, FunctionShifter, DataFormatter
+from agently.utils import Settings, FunctionShifter, DataFormatter, DataLocator
 
 if TYPE_CHECKING:
     from agently.core import PluginManager
     from agently.types.data import AgentlyModelResponseMessage, PromptStandardSlot, StreamingData, SerializableValue
     from agently.types.plugins import ModelRequester, ResponseParser
+    from pydantic import BaseModel
 
 
 class ModelResponseResult:
@@ -39,6 +40,7 @@ class ModelResponseResult:
         response_generator: AsyncGenerator["AgentlyModelResponseMessage", None],
         plugin_manager: "PluginManager",
         settings: Settings,
+        extension_handlers: ExtensionHandlers,
     ):
         self.agent_name = agent_name
         self.plugin_manager = plugin_manager
@@ -50,19 +52,145 @@ class ModelResponseResult:
                 str(self.settings["plugins.ResponseParser.activate"]),
             ),
         )
-        _response_parser = ResponseParser(agent_name, response_id, prompt, response_generator, self.settings)
+        self._response_id = response_id
+        self._extension_handlers = extension_handlers
+        self._response_parser = ResponseParser(agent_name, response_id, prompt, response_generator, self.settings)
         self.prompt = prompt
-        self.full_result_data = _response_parser.full_result_data
-        self.get_meta = _response_parser.get_meta
-        self.async_get_meta = _response_parser.async_get_meta
-        self.get_text = _response_parser.get_text
-        self.async_get_text = _response_parser.async_get_text
-        self.get_data = _response_parser.get_data
-        self.async_get_data = _response_parser.async_get_data
-        self.get_data_object = _response_parser.get_data_object
-        self.async_get_data_object = _response_parser.async_get_data_object
-        self.get_generator = _response_parser.get_generator
-        self.get_async_generator = _response_parser.get_async_generator
+        self.full_result_data = self._response_parser.full_result_data
+        self.get_meta = self._response_parser.get_meta
+        self.async_get_meta = self._response_parser.async_get_meta
+        self.get_text = self._response_parser.get_text
+        self.async_get_text = self._response_parser.async_get_text
+        # self.get_data = self._response_parser.get_data
+        # self.async_get_data = self._response_parser.async_get_data
+        # self.get_data_object = self._response_parser.get_data_object
+        # self.async_get_data_object = self._response_parser.async_get_data_object
+        self.get_data = FunctionShifter.syncify(self.async_get_data)
+        self.get_data_object = FunctionShifter.syncify(self.async_get_data_object)
+        self.get_generator = self._response_parser.get_generator
+        self.get_async_generator = self._response_parser.get_async_generator
+
+    @overload
+    async def async_get_data(
+        self,
+        *,
+        type: Literal['parsed'],
+        ensure_keys: list[str],
+        key_style: Literal["dot", "slash"] = "dot",
+        max_retries: int = 3,
+        raise_ensure_failure: bool = True,
+        _retry_count: int = 0,
+    ) -> dict[str, Any]: ...
+
+    @overload
+    async def async_get_data(
+        self,
+        *,
+        type: Literal['original', 'parsed', 'all'] = "parsed",
+        ensure_keys: list[str] | None = None,
+        key_style: Literal["dot", "slash"] = "dot",
+        max_retries: int = 3,
+        raise_ensure_failure: bool = True,
+        _retry_count: int = 0,
+    ) -> Any: ...
+
+    async def async_get_data(
+        self,
+        *,
+        type: Literal['original', 'parsed', 'all'] = "parsed",
+        ensure_keys: list[str] | None = None,
+        key_style: Literal["dot", "slash"] = "dot",
+        max_retries: int = 3,
+        raise_ensure_failure: bool = True,
+        _retry_count: int = 0,
+    ) -> Any:
+        if type == "parsed" and ensure_keys:
+            try:
+                data = await self._response_parser.async_get_data(type=type)
+                for ensure_key in ensure_keys:
+                    EMPTY = object()
+                    if DataLocator.locate_path_in_dict(data, ensure_key, key_style, default=EMPTY) is EMPTY:
+                        raise
+                return data
+            except:
+                from agently.base import async_system_message
+
+                await async_system_message(
+                    "MODEL_REQUEST",
+                    {
+                        "agent_name": self.agent_name,
+                        "response_id": self._response_id,
+                        "content": {
+                            "stage": "No Target Data in Response, Preparing Retry",
+                            "detail": f"\n[Response]: { await self.async_get_text() }\n"
+                            f"[Retried Times]: { _retry_count }",
+                        },
+                    },
+                    self.settings,
+                )
+
+                if _retry_count < max_retries:
+                    return await ModelResponse(
+                        self.agent_name,
+                        self.plugin_manager,
+                        self.settings,
+                        self.prompt,
+                        self._extension_handlers,
+                    ).result.async_get_data(
+                        type=type,
+                        ensure_keys=ensure_keys,
+                        key_style=key_style,
+                        max_retries=max_retries,
+                        raise_ensure_failure=raise_ensure_failure,
+                        _retry_count=_retry_count + 1,
+                    )
+                else:
+                    if raise_ensure_failure:
+                        raise ValueError(
+                            f"Can not generate ensure keys { ensure_keys } within { max_retries } retires."
+                        )
+                    else:
+                        return await self._response_parser.async_get_data(type=type)
+        return await self._response_parser.async_get_data(type=type)
+
+    @overload
+    async def async_get_data_object(
+        self,
+        *,
+        ensure_keys: list[str],
+        key_style: Literal["dot", "slash"] = "dot",
+        max_retries: int = 3,
+        raise_ensure_failure: bool = True,
+    ) -> "BaseModel": ...
+
+    @overload
+    async def async_get_data_object(
+        self,
+        *,
+        ensure_keys: None,
+        key_style: Literal["dot", "slash"] = "dot",
+        max_retries: int = 3,
+        raise_ensure_failure: bool = True,
+    ) -> "BaseModel | None": ...
+
+    async def async_get_data_object(
+        self,
+        *,
+        ensure_keys: list[str] | None = None,
+        key_style: Literal["dot", "slash"] = "dot",
+        max_retries: int = 3,
+        raise_ensure_failure: bool = True,
+    ):
+        if ensure_keys:
+            await self.async_get_data(
+                ensure_keys=ensure_keys,
+                key_style=key_style,
+                max_retries=max_retries,
+                _retry_count=0,
+                raise_ensure_failure=raise_ensure_failure,
+            )
+            return await self._response_parser.async_get_data_object()
+        return await self._response_parser.async_get_data_object()
 
 
 class ModelResponse:
@@ -98,8 +226,8 @@ class ModelResponse:
             self._get_response_generator(),
             self.plugin_manager,
             self.settings,
+            self.extension_handlers,
         )
-        self.get_result = self.result
         self.get_meta = self.result.get_meta
         self.async_get_meta = self.result.async_get_meta
         self.get_text = self.result.get_text
@@ -406,7 +534,7 @@ class ModelRequest:
         self.prompt.clear()
         return response
 
-    async def get_result(self):
+    def get_result(self):
         return self.get_response().result
 
     async def async_get_meta(self):
@@ -419,11 +547,35 @@ class ModelRequest:
         self,
         *,
         type: Literal['original', 'parsed', 'all'] = "parsed",
+        ensure_keys: list[str] | None = None,
+        key_style: Literal["dot", "slash"] = "dot",
+        max_retries: int = 3,
+        raise_ensure_failure: bool = True,
     ):
-        return await self.get_response().async_get_data(type=type)
+        response = self.get_response()
+        return await response.async_get_data(
+            type=type,
+            ensure_keys=ensure_keys,
+            key_style=key_style,
+            max_retries=max_retries,
+            raise_ensure_failure=raise_ensure_failure,
+        )
 
-    async def async_get_data_object(self):
-        return await self.get_response().async_get_data_object()
+    async def async_get_data_object(
+        self,
+        *,
+        ensure_keys: list[str] | None = None,
+        key_style: Literal["dot", "slash"] = "dot",
+        max_retries: int = 3,
+        raise_ensure_failure: bool = True,
+    ):
+        response = self.get_response()
+        return await response.async_get_data_object(
+            ensure_keys=ensure_keys,
+            key_style=key_style,
+            max_retries=max_retries,
+            raise_ensure_failure=raise_ensure_failure,
+        )
 
     @overload
     def get_generator(

agently-4.0.6.8/agently/integrations/chromadb.py

@@ -0,0 +1,283 @@
+from agently.utils import LazyImport
+
+LazyImport.import_package("chromadb")
+
+from typing import Literal, Callable, TypedDict, Any, TYPE_CHECKING, overload
+from itertools import zip_longest
+
+from chromadb import Client as ChromaDBClient
+from chromadb.config import Settings
+from chromadb.api.types import EmbeddingFunction
+
+if TYPE_CHECKING:
+    from chromadb.api.types import (
+        Documents,
+        Embedding,
+        Embeddings,
+        QueryResult,
+        Schema,
+        DataLoader,
+        Loadable,
+        Where,
+        WhereDocument,
+    )
+    from chromadb.api.collection_configuration import CreateCollectionConfiguration
+    from chromadb.api import ClientAPI
+    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 ChromaResults:
+    def __init__(
+        self,
+        *,
+        queries: str | list[str],
+        results: "QueryResult",
+        distance: float | None = None,
+    ):
+        if isinstance(queries, str):
+            queries = [queries]
+
+        ids = results.get("ids") or []
+        documents = results.get("documents")
+        metadatas = results.get("metadatas")
+        distances = results.get("distances")
+
+        if ids and len(queries) != len(ids):
+            raise ValueError(
+                f"The length of queries does not equal the length of results['ids'].\nQueries: {queries}\nIds: {ids}"
+            )
+
+        self._chroma_results = results
+        self._results: dict[str, list[dict]] = {}
+
+        doc_iter = documents if documents is not None else []
+        meta_iter = metadatas if metadatas is not None else []
+        dist_iter = distances if distances is not None else []
+
+        for query, row_ids, row_documents, row_metadatas, row_distances in zip_longest(
+            queries, ids, doc_iter, meta_iter, dist_iter, fillvalue=None
+        ):
+            row_ids = row_ids or []
+            query_results: list[dict[str, Any]] = []
+            for id_, doc, meta, dist in zip_longest(
+                row_ids, row_documents or [], row_metadatas or [], row_distances or [], fillvalue=None
+            ):
+                query_result = {"id": id_, "document": doc, "metadata": meta, "distance": dist}
+                if distance is None:
+                    query_results.append(query_result)
+                else:
+                    if isinstance(dist, (int, float)) and dist < distance:
+                        query_results.append(query_result)
+
+            if query:
+                self._results[query] = query_results
+
+    def get_original_results(self):
+        return self._chroma_results
+
+    def get(self, *, simplify_single_result: bool = False):
+        if simplify_single_result:
+            results = list(self._results.values())
+            if len(results) == 1:
+                return results[0]
+        return self._results
+
+
+class ChromaEmbeddingFunction(EmbeddingFunction):
+    def __init__(
+        self,
+        *,
+        embedding_agent: "BaseAgent",
+    ):
+        def embedding_function_by_agent(texts: list[str]) -> "Embeddings":
+            return embedding_agent.input(texts).start()
+
+        self.embedding_function = embedding_function_by_agent
+
+    def __call__(self, documents: "Documents | list[str] | str") -> "Embeddings":
+        if isinstance(documents, str):
+            documents = [documents]
+        return self.embedding_function([document for document in documents])
+
+
+class ChromaCollection:
+
+    def __init__(
+        self,
+        collection_name: str,
+        *,
+        conn: "ClientAPI | None" = None,
+        schema: "Schema | None" = None,
+        configuration: "CreateCollectionConfiguration | None" = None,
+        metadata: dict[str, Any] | None = None,
+        embedding_agent: "BaseAgent | None" = None,
+        data_loader: "DataLoader[Loadable] | None" = None,
+        get_or_create: bool = False,
+        hnsw_space: Literal["l2", "cosine", "ip"] = "cosine",
+    ):
+        if conn is None:
+            conn = ChromaDBClient(Settings(anonymized_telemetry=False))
+
+        if metadata is None:
+            metadata = {}
+
+        metadata["hnsw:space"] = hnsw_space
+
+        self.embedding_function = (
+            ChromaEmbeddingFunction(embedding_agent=embedding_agent) if embedding_agent is not None else None
+        )
+
+        self._collection = conn.create_collection(
+            collection_name,
+            schema=schema,
+            configuration=configuration,
+            metadata=metadata,
+            embedding_function=self.embedding_function,
+            data_loader=data_loader,
+            get_or_create=get_or_create,
+        )
+
+    def add(
+        self,
+        data: ChromaDataDict | list[ChromaDataDict] | ChromaData,
+        *,
+        embedding_function: "Callable[[str | list[str]], Embeddings] | None" = None,
+    ):
+        embedding_function = embedding_function or self.embedding_function
+        if embedding_function is None:
+            raise NotImplementedError(
+                f"Embedding function must be assigned either in ChromaCollection initialize or .add() method."
+            )
+        if not isinstance(data, ChromaData):
+            data = ChromaData(data, embedding_function=embedding_function)
+        self._collection.add(**data.get_kwargs())
+        return self
+
+    @overload
+    def query(
+        self,
+        query_or_queries: str,
+        *,
+        embedding_function: "Callable[[str | list[str]], Embeddings] | None" = None,
+        top_n: int | None = None,
+        where: "Where | None" = None,
+        where_document: "WhereDocument | None" = None,
+        distance: float | None = None,
+    ) -> list[dict[str, Any]]: ...
+
+    @overload
+    def query(
+        self,
+        query_or_queries: list[str],
+        *,
+        embedding_function: "Callable[[str | list[str]], Embeddings] | None" = None,
+        top_n: int | None = None,
+        where: "Where | None" = None,
+        where_document: "WhereDocument | None" = None,
+        distance: float | None = None,
+    ) -> dict[str, list[dict[str, Any]]]: ...
+
+    def query(
+        self,
+        query_or_queries: str | list[str],
+        *,
+        embedding_function: "Callable[[str | list[str]], Embeddings] | None" = None,
+        top_n: int | None = None,
+        where: "Where | None" = None,
+        where_document: "WhereDocument | None" = None,
+        distance: float | None = None,
+    ):
+        embedding_function = embedding_function or self.embedding_function
+        if embedding_function is None:
+            raise NotImplementedError(
+                f"Embedding function must be assigned either in ChromaCollection initialize or .query() method."
+            )
+        if not isinstance(query_or_queries, list):
+            query_or_queries = [query_or_queries]
+        return ChromaResults(
+            queries=query_or_queries,
+            results=self._collection.query(
+                query_embeddings=embedding_function(query_or_queries),
+                n_results=top_n or 10,
+                where=where,
+                where_document=where_document,
+            ),
+            distance=distance,
+        ).get(simplify_single_result=True)
+
+    def query_embeddings(
+        self,
+        embeddings_dict: dict[str, "Embedding"],
+        *,
+        top_n: int | None = None,
+        where: "Where | None" = None,
+        where_document: "WhereDocument | None" = None,
+        distance: float | None = None,
+    ):
+        queries = [query for query in embeddings_dict.keys()]
+        embeddings = [embeddings for embeddings in embeddings_dict.values()]
+        return ChromaResults(
+            queries=queries,
+            results=self._collection.query(
+                query_embeddings=embeddings,
+                n_results=top_n or 10,
+                where=where,
+                where_document=where_document,
+            ),
+            distance=distance,
+        ).get(simplify_single_result=True)

{agently-4.0.6.6 → agently-4.0.6.8}/pyproject.toml

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

agently-4.0.6.6/agently/integrations/chromadb.py

@@ -1,167 +0,0 @@
-from agently.utils import LazyImport, FunctionShifter
-
-LazyImport.import_package("chromadb")
-
-from typing import Callable, TypedDict, Any, TYPE_CHECKING
-
-from chromadb.api.types import EmbeddingFunction, DefaultEmbeddingFunction
-
-if TYPE_CHECKING:
-    from chromadb.api.types import (
-        Documents,
-        Embedding,
-        Embeddings,
-        QueryResult,
-        Schema,
-        CollectionMetadata,
-        DataLoader,
-        Loadable,
-    )
-    from chromadb.api.collection_configuration import CreateCollectionConfiguration
-    from chromadb.api import ClientAPI
-    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 ChromaResults:
-    def __init__(
-        self,
-        *,
-        queries: str | list[str],
-        results: "QueryResult",
-    ):
-        if isinstance(queries, str):
-            queries = [queries]
-        if len(queries) != len(results["documents"] or []):
-            raise ValueError(
-                f"The length of queries does not equal the length of results.\nQueries: { queries }\nResults: { results }"
-            )
-        self._chroma_results = results
-        self._results = {}
-        for query_index, query in enumerate(queries):
-            for result_index, id in enumerate(results["ids"][query_index]):
-                result = {
-                    "id": id,
-                    "document": results["documents"][query_index][result_index] if results["documents"] else None,
-                    "metadata": results["metadatas"][query_index][result_index] if results["metadatas"] else None,
-                    "distance": results["distances"][query_index][result_index] if results["distances"] else None,
-                }
-                self._results[query] = result
-
-    def get_original_results(self):
-        return self._chroma_results
-
-    def get(self):
-        return self._results
-
-
-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])
-
-
-class ChromaCollection:
-    def __init__(
-        self,
-        conn: "ClientAPI",
-        collection_name: str,
-        *,
-        schema: "Schema | None" = None,
-        configuration: "CreateCollectionConfiguration | None" = None,
-        metadata: None = None,
-        embedding_function: EmbeddingFunction | None = None,
-        agent: "BaseAgent | None" = None,
-        data_loader: "DataLoader[Loadable] | None" = None,
-        get_or_create: bool = False,
-    ):
-        if embedding_function:
-            self._embedding_function = embedding_function
-        elif agent:
-            self._embedding_function = ChromaEmbeddingFunction(agent=agent)
-        else:
-            self._embedding_function = DefaultEmbeddingFunction()
-
-        self._collection = conn.create_collection(
-            collection_name,
-            schema=schema,
-            configuration=configuration,
-            metadata=metadata,
-            embedding_function=embedding_function,
-            data_loader=data_loader,
-            get_or_create=get_or_create,
-        )
-
-    def add(self): ...