GitHub

embedding_model

API reference for embedding_model.

OpenAI's Embeddings API as an EmbeddingModel (Effect's OpenAiEmbeddingModel)::

program.pipe(
    fx.provide(embedding_model.model("text-embedding-3-small", dimensions=1536).layer)
)

Requests with the same Config and OpenAiConfig are batched into one call.

Types

TypeDefinitionDescription
Modeltype Model = Literal['text-embedding-ada-002', 'text-embedding-3-small', 'text-embedding-3-large']

Model names (any other string is accepted too).

ModelConfigtype ModelConfig = ConfigService | Mapping[str, Any]

Classes

Functions

make

make(*, model, config=None) -> Effect[em.Service, Never, OpenAiClient]

An EmbeddingModel for model; a provided Config overrides config per request. Vectors come back in input order; a missing, duplicate or non-vector entry fails with InvalidOutputError.

ParameterTypeDescription
modelModel | str
configModelConfig | None = None

Returns Effect[em.Service, Never, OpenAiClient]

def make(
    *, model: Model | str, config: ModelConfig | None = None
) -> Effect[em.Service, Never, OpenAiClient]:
    """An ``EmbeddingModel`` for ``model``; a provided ``Config`` overrides
    ``config`` per request. Vectors come back in input order; a missing,
    duplicate or non-vector entry fails with ``InvalidOutputError``."""

    def build(client: ClientService) -> Effect[em.Service]:
        def embed_many(options: em.ProviderOptions) -> Effect[em.ProviderResponse, AiError]:
            return (
                P.current_config(Config, {"model": model}, config)
                .flat_map(
                    lambda cfg: client.create_embedding(
                        cast("Any", {**cfg, "input": list(options.inputs)})
                    )
                )
                .flat_map(
                    lambda response: provider_response(len(options.inputs), cast("Any", response))
                )
            )

        return em.make(embed_many=embed_many, batch_key=_batch_key)

    return OpenAiClient().flat_map(build)

layer

layer(*, model, config=None) -> L.Layer[em.EmbeddingModel, Never, OpenAiClient]
ParameterTypeDescription
modelModel | str
configModelConfig | None = None

Returns L.Layer[em.EmbeddingModel, Never, OpenAiClient]

def layer(
    *, model: Model | str, config: ModelConfig | None = None
) -> L.Layer[em.EmbeddingModel, Never, OpenAiClient]:
    return L.effect(em.EmbeddingModel, make(model=model, config=config))

model

model(model, *, dimensions, config=None) -> M.Model[em.EmbeddingModel | em.Dimensions, OpenAiClient]

The model and its Dimensions as a Model (provider "openai"); dimensions is sent with each request.

ParameterTypeDescription
modelModel | str
dimensionsint
configModelConfig | None = None

Returns M.Model[em.EmbeddingModel | em.Dimensions, OpenAiClient]

def model(
    model: Model | str, *, dimensions: int, config: ModelConfig | None = None
) -> M.Model[em.EmbeddingModel | em.Dimensions, OpenAiClient]:
    """The model and its ``Dimensions`` as a ``Model`` (provider
    ``"openai"``); ``dimensions`` is sent with each request."""
    merged = {**(config or {}), "dimensions": dimensions}
    return M.make(
        "openai",
        model,
        L.merge(layer(model=model, config=merged), L.succeed(em.Dimensions, dimensions)),
    )

with_config_override

with_config_override(overrides) -> P.WithConfigOverride[ConfigService]

Run an effect with overrides merged over the current Config. Use with .pipe.

ParameterTypeDescription
overridesConfigService

Returns P.WithConfigOverride[ConfigService]

def with_config_override(overrides: ConfigService) -> P.WithConfigOverride[ConfigService]:
    """Run an effect with ``overrides`` merged over the current ``Config``.
    Use with ``.pipe``."""
    return P.WithConfigOverride(Config, overrides)